home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 January: Mac OS SDK / Dev.CD Jan 97 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Interfaces / PInterfaces / QuickTimeComponents.p < prev    next >
Encoding:
Text File  |  1996-09-22  |  93.6 KB  |  2,415 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        QuickTimeComponents.p
  3.  
  4.      Contains:    QuickTime Interfaces.
  5.  
  6.      Version:    Technology:    QuickTime 2.5
  7.                  Release:    Universal Interfaces 2.1.4
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT QuickTimeComponents;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __QUICKTIMECOMPONENTS__}
  28. {$SETC __QUICKTIMECOMPONENTS__ := 1}
  29.  
  30. {$I+}
  31. {$SETC QuickTimeComponentsIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __COMPONENTS__}
  35. {$I Components.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __IMAGECOMPRESSION__}
  38. {$I ImageCompression.p}
  39. {$ENDC}
  40. {$IFC UNDEFINED __MOVIES__}
  41. {$I Movies.p}
  42. {$ENDC}
  43. {$IFC UNDEFINED __QUICKDRAW__}
  44. {$I Quickdraw.p}
  45. {$ENDC}
  46. {$IFC UNDEFINED __VIDEO__}
  47. {$I Video.p}
  48. {$ENDC}
  49. {$IFC UNDEFINED __MEMORY__}
  50. {$I Memory.p}
  51. {$ENDC}
  52. {$IFC UNDEFINED __SOUND__}
  53. {$I Sound.p}
  54. {$ENDC}
  55. {$IFC UNDEFINED __QUICKTIMEMUSIC__}
  56. {$I QuickTimeMusic.p}
  57. {$ENDC}
  58.  
  59. {$PUSH}
  60. {$ALIGN MAC68K}
  61. {$LibExport+}
  62.  
  63.  
  64. CONST
  65.     clockComponentType            = 'clok';
  66.     systemTickClock                = 'tick';                        {  subtype: 60ths since boot         }
  67.     systemSecondClock            = 'seco';                        {  subtype: seconds since 1904         }
  68.     systemMillisecondClock        = 'mill';                        {  subtype: 1000ths since boot         }
  69.     systemMicrosecondClock        = 'micr';                        {  subtype: 1000000ths since boot     }
  70.  
  71.     kClockRateIsLinear            = 1;
  72.     kClockImplementsCallBacks    = 2;
  73.  
  74. { * These are Clock procedures * }
  75. FUNCTION ClockGetTime(aClock: ComponentInstance; VAR out: TimeRecord): ComponentResult;
  76.     {$IFC NOT GENERATINGCFM}
  77.     INLINE $2F3C, $0004, $0001, $7000, $A82A;
  78.     {$ENDC}
  79. FUNCTION ClockNewCallBack(aClock: ComponentInstance; tb: TimeBase; callBackType: INTEGER): QTCallBack;
  80.     {$IFC NOT GENERATINGCFM}
  81.     INLINE $2F3C, $0006, $0002, $7000, $A82A;
  82.     {$ENDC}
  83. FUNCTION ClockDisposeCallBack(aClock: ComponentInstance; cb: QTCallBack): ComponentResult;
  84.     {$IFC NOT GENERATINGCFM}
  85.     INLINE $2F3C, $0004, $0003, $7000, $A82A;
  86.     {$ENDC}
  87. FUNCTION ClockCallMeWhen(aClock: ComponentInstance; cb: QTCallBack; param1: LONGINT; param2: LONGINT; param3: LONGINT): ComponentResult;
  88.     {$IFC NOT GENERATINGCFM}
  89.     INLINE $2F3C, $0010, $0004, $7000, $A82A;
  90.     {$ENDC}
  91. FUNCTION ClockCancelCallBack(aClock: ComponentInstance; cb: QTCallBack): ComponentResult;
  92.     {$IFC NOT GENERATINGCFM}
  93.     INLINE $2F3C, $0004, $0005, $7000, $A82A;
  94.     {$ENDC}
  95. FUNCTION ClockRateChanged(aClock: ComponentInstance; cb: QTCallBack): ComponentResult;
  96.     {$IFC NOT GENERATINGCFM}
  97.     INLINE $2F3C, $0004, $0006, $7000, $A82A;
  98.     {$ENDC}
  99. FUNCTION ClockTimeChanged(aClock: ComponentInstance; cb: QTCallBack): ComponentResult;
  100.     {$IFC NOT GENERATINGCFM}
  101.     INLINE $2F3C, $0004, $0007, $7000, $A82A;
  102.     {$ENDC}
  103. FUNCTION ClockSetTimeBase(aClock: ComponentInstance; tb: TimeBase): ComponentResult;
  104.     {$IFC NOT GENERATINGCFM}
  105.     INLINE $2F3C, $0004, $0008, $7000, $A82A;
  106.     {$ENDC}
  107. FUNCTION ClockStartStopChanged(aClock: ComponentInstance; cb: QTCallBack; startChanged: BOOLEAN; stopChanged: BOOLEAN): ComponentResult;
  108.     {$IFC NOT GENERATINGCFM}
  109.     INLINE $2F3C, $0008, $0009, $7000, $A82A;
  110.     {$ENDC}
  111. FUNCTION ClockGetRate(aClock: ComponentInstance; VAR rate: Fixed): ComponentResult;
  112.     {$IFC NOT GENERATINGCFM}
  113.     INLINE $2F3C, $0004, $000A, $7000, $A82A;
  114.     {$ENDC}
  115.  
  116. CONST
  117.     StandardCompressionType        = 'scdi';
  118.     StandardCompressionSubType    = 'imag';
  119.  
  120.  
  121. TYPE
  122.     SCModalFilterProcPtr = ProcPtr;  { FUNCTION SCModalFilter(theDialog: DialogPtr; VAR theEvent: EventRecord; VAR itemHit: INTEGER; refcon: LONGINT): BOOLEAN; }
  123.  
  124.     SCModalHookProcPtr = ProcPtr;  { FUNCTION SCModalHook(theDialog: DialogPtr; itemHit: INTEGER; params: UNIV Ptr; refcon: LONGINT): INTEGER; }
  125.  
  126.     SCModalFilterUPP = UniversalProcPtr;
  127.     SCModalHookUPP = UniversalProcPtr;
  128. {     Preference flags. }
  129.  
  130. CONST
  131.     scListEveryCodec            = $00000002;
  132.     scAllowZeroFrameRate        = $00000004;
  133.     scAllowZeroKeyFrameRate        = $00000008;
  134.     scShowBestDepth                = $00000010;
  135.     scUseMovableModal            = $00000020;
  136.  
  137. {     Possible test flags for setting test image. }
  138.     scPreferCropping            = $01;
  139.     scPreferScaling                = $02;
  140.     scPreferScalingAndCropping    = $03;
  141.  
  142. {     Dimensions of the image preview box. }
  143.     scTestImageWidth            = 80;
  144.     scTestImageHeight            = 80;
  145.  
  146. {     Possible items returned by hookProc. }
  147.     scOKItem                    = 1;
  148.     scCancelItem                = 2;
  149.     scCustomItem                = 3;
  150.  
  151. {     Result returned when user cancelled. }
  152.     scUserCancelled                = 1;
  153.  
  154. {     Get/SetInfo structures. }
  155.  
  156. TYPE
  157.     SCSpatialSettingsPtr = ^SCSpatialSettings;
  158.     SCSpatialSettings = RECORD
  159.         codecType:                CodecType;
  160.         codec:                    CodecComponent;
  161.         depth:                    INTEGER;
  162.         spatialQuality:            CodecQ;
  163.     END;
  164.  
  165.     SCTemporalSettingsPtr = ^SCTemporalSettings;
  166.     SCTemporalSettings = RECORD
  167.         temporalQuality:        CodecQ;
  168.         frameRate:                Fixed;
  169.         keyFrameRate:            LONGINT;
  170.     END;
  171.  
  172.     SCDataRateSettingsPtr = ^SCDataRateSettings;
  173.     SCDataRateSettings = RECORD
  174.         dataRate:                LONGINT;
  175.         frameDuration:            LONGINT;
  176.         minSpatialQuality:        CodecQ;
  177.         minTemporalQuality:        CodecQ;
  178.     END;
  179.  
  180.     SCExtendedProcsPtr = ^SCExtendedProcs;
  181.     SCExtendedProcs = RECORD
  182.         filterProc:                SCModalFilterUPP;
  183.         hookProc:                SCModalHookUPP;
  184.         refcon:                    LONGINT;
  185.         customName:                Str31;
  186.     END;
  187.  
  188. {     Get/SetInfo selectors }
  189.  
  190. CONST
  191.     scSpatialSettingsType        = 'sptl';                        {  pointer to SCSpatialSettings struct }
  192.     scTemporalSettingsType        = 'tprl';                        {  pointer to SCTemporalSettings struct }
  193.     scDataRateSettingsType        = 'drat';                        {  pointer to SCDataRateSettings struct }
  194.     scColorTableType            = 'clut';                        {  pointer to CTabHandle }
  195.     scProgressProcType            = 'prog';                        {  pointer to ProgressRecord struct }
  196.     scExtendedProcsType            = 'xprc';                        {  pointer to SCExtendedProcs struct }
  197.     scPreferenceFlagsType        = 'pref';                        {  pointer to long }
  198.     scSettingsStateType            = 'ssta';                        {  pointer to Handle }
  199.     scSequenceIDType            = 'sequ';                        {  pointer to ImageSequence }
  200.     scWindowPositionType        = 'wndw';                        {  pointer to Point }
  201.     scCodecFlagsType            = 'cflg';                        {  pointer to CodecFlags }
  202.     scCodecSettingsType            = 'cdec';                        {  pointer to Handle }
  203.     scForceKeyValueType            = 'ksim';                        {  pointer to long }
  204.  
  205. {     scTypeNotFoundErr returned by Get/SetInfo when type cannot be found. }
  206.  
  207. TYPE
  208.     SCParamsPtr = ^SCParams;
  209.     SCParams = RECORD
  210.         flags:                    LONGINT;
  211.         theCodecType:            CodecType;
  212.         theCodec:                CodecComponent;
  213.         spatialQuality:            CodecQ;
  214.         temporalQuality:        CodecQ;
  215.         depth:                    INTEGER;
  216.         frameRate:                Fixed;
  217.         keyFrameRate:            LONGINT;
  218.         reserved1:                LONGINT;
  219.         reserved2:                LONGINT;
  220.     END;
  221.  
  222.  
  223. CONST
  224.     scGetCompression            = 1;
  225.     scShowMotionSettings        = $00000001;
  226.     scSettingsChangedItem        = -1;
  227.  
  228.     scCompressFlagIgnoreIdenticalFrames = 1;
  229.  
  230. { * These are Progress procedures * }
  231. FUNCTION SCGetCompressionExtended(ci: ComponentInstance; VAR params: SCParams; where: Point; filterProc: SCModalFilterUPP; hookProc: SCModalHookUPP; refcon: LONGINT; customName: StringPtr): ComponentResult;
  232.     {$IFC NOT GENERATINGCFM}
  233.     INLINE $2F3C, $0018, $0001, $7000, $A82A;
  234.     {$ENDC}
  235. FUNCTION SCPositionRect(ci: ComponentInstance; VAR rp: Rect; VAR where: Point): ComponentResult;
  236.     {$IFC NOT GENERATINGCFM}
  237.     INLINE $2F3C, $0008, $0002, $7000, $A82A;
  238.     {$ENDC}
  239. FUNCTION SCPositionDialog(ci: ComponentInstance; id: INTEGER; VAR where: Point): ComponentResult;
  240.     {$IFC NOT GENERATINGCFM}
  241.     INLINE $2F3C, $0006, $0003, $7000, $A82A;
  242.     {$ENDC}
  243. FUNCTION SCSetTestImagePictHandle(ci: ComponentInstance; testPict: PicHandle; VAR testRect: Rect; testFlags: INTEGER): ComponentResult;
  244.     {$IFC NOT GENERATINGCFM}
  245.     INLINE $2F3C, $000A, $0004, $7000, $A82A;
  246.     {$ENDC}
  247. FUNCTION SCSetTestImagePictFile(ci: ComponentInstance; testFileRef: INTEGER; VAR testRect: Rect; testFlags: INTEGER): ComponentResult;
  248.     {$IFC NOT GENERATINGCFM}
  249.     INLINE $2F3C, $0008, $0005, $7000, $A82A;
  250.     {$ENDC}
  251. FUNCTION SCSetTestImagePixMap(ci: ComponentInstance; testPixMap: PixMapHandle; VAR testRect: Rect; testFlags: INTEGER): ComponentResult;
  252.     {$IFC NOT GENERATINGCFM}
  253.     INLINE $2F3C, $000A, $0006, $7000, $A82A;
  254.     {$ENDC}
  255. FUNCTION SCGetBestDeviceRect(ci: ComponentInstance; VAR r: Rect): ComponentResult;
  256.     {$IFC NOT GENERATINGCFM}
  257.     INLINE $2F3C, $0004, $0007, $7000, $A82A;
  258.     {$ENDC}
  259. FUNCTION SCRequestImageSettings(ci: ComponentInstance): ComponentResult;
  260.     {$IFC NOT GENERATINGCFM}
  261.     INLINE $2F3C, $0000, $000A, $7000, $A82A;
  262.     {$ENDC}
  263. FUNCTION SCCompressImage(ci: ComponentInstance; src: PixMapHandle; {CONST}VAR srcRect: Rect; VAR desc: ImageDescriptionHandle; VAR data: Handle): ComponentResult;
  264.     {$IFC NOT GENERATINGCFM}
  265.     INLINE $2F3C, $0010, $000B, $7000, $A82A;
  266.     {$ENDC}
  267. FUNCTION SCCompressPicture(ci: ComponentInstance; srcPicture: PicHandle; dstPicture: PicHandle): ComponentResult;
  268.     {$IFC NOT GENERATINGCFM}
  269.     INLINE $2F3C, $0008, $000C, $7000, $A82A;
  270.     {$ENDC}
  271. FUNCTION SCCompressPictureFile(ci: ComponentInstance; srcRefNum: INTEGER; dstRefNum: INTEGER): ComponentResult;
  272.     {$IFC NOT GENERATINGCFM}
  273.     INLINE $2F3C, $0004, $000D, $7000, $A82A;
  274.     {$ENDC}
  275. FUNCTION SCRequestSequenceSettings(ci: ComponentInstance): ComponentResult;
  276.     {$IFC NOT GENERATINGCFM}
  277.     INLINE $2F3C, $0000, $000E, $7000, $A82A;
  278.     {$ENDC}
  279. FUNCTION SCCompressSequenceBegin(ci: ComponentInstance; src: PixMapHandle; {CONST}VAR srcRect: Rect; VAR desc: ImageDescriptionHandle): ComponentResult;
  280.     {$IFC NOT GENERATINGCFM}
  281.     INLINE $2F3C, $000C, $000F, $7000, $A82A;
  282.     {$ENDC}
  283. FUNCTION SCCompressSequenceFrame(ci: ComponentInstance; src: PixMapHandle; {CONST}VAR srcRect: Rect; VAR data: Handle; VAR dataSize: LONGINT; VAR notSyncFlag: INTEGER): ComponentResult;
  284.     {$IFC NOT GENERATINGCFM}
  285.     INLINE $2F3C, $0014, $0010, $7000, $A82A;
  286.     {$ENDC}
  287. FUNCTION SCCompressSequenceEnd(ci: ComponentInstance): ComponentResult;
  288.     {$IFC NOT GENERATINGCFM}
  289.     INLINE $2F3C, $0000, $0011, $7000, $A82A;
  290.     {$ENDC}
  291. FUNCTION SCDefaultPictHandleSettings(ci: ComponentInstance; srcPicture: PicHandle; motion: INTEGER): ComponentResult;
  292.     {$IFC NOT GENERATINGCFM}
  293.     INLINE $2F3C, $0006, $0012, $7000, $A82A;
  294.     {$ENDC}
  295. FUNCTION SCDefaultPictFileSettings(ci: ComponentInstance; srcRef: INTEGER; motion: INTEGER): ComponentResult;
  296.     {$IFC NOT GENERATINGCFM}
  297.     INLINE $2F3C, $0004, $0013, $7000, $A82A;
  298.     {$ENDC}
  299. FUNCTION SCDefaultPixMapSettings(ci: ComponentInstance; src: PixMapHandle; motion: INTEGER): ComponentResult;
  300.     {$IFC NOT GENERATINGCFM}
  301.     INLINE $2F3C, $0006, $0014, $7000, $A82A;
  302.     {$ENDC}
  303. FUNCTION SCGetInfo(ci: ComponentInstance; infoType: OSType; info: UNIV Ptr): ComponentResult;
  304.     {$IFC NOT GENERATINGCFM}
  305.     INLINE $2F3C, $0008, $0015, $7000, $A82A;
  306.     {$ENDC}
  307. FUNCTION SCSetInfo(ci: ComponentInstance; infoType: OSType; info: UNIV Ptr): ComponentResult;
  308.     {$IFC NOT GENERATINGCFM}
  309.     INLINE $2F3C, $0008, $0016, $7000, $A82A;
  310.     {$ENDC}
  311. FUNCTION SCNewGWorld(ci: ComponentInstance; VAR gwp: GWorldPtr; VAR rp: Rect; flags: GWorldFlags): ComponentResult;
  312.     {$IFC NOT GENERATINGCFM}
  313.     INLINE $2F3C, $000C, $0017, $7000, $A82A;
  314.     {$ENDC}
  315. FUNCTION SCSetCompressFlags(ci: ComponentInstance; flags: LONGINT): ComponentResult;
  316.     {$IFC NOT GENERATINGCFM}
  317.     INLINE $2F3C, $0004, $0018, $7000, $A82A;
  318.     {$ENDC}
  319. FUNCTION SCGetCompressFlags(ci: ComponentInstance; VAR flags: LONGINT): ComponentResult;
  320.     {$IFC NOT GENERATINGCFM}
  321.     INLINE $2F3C, $0004, $0019, $7000, $A82A;
  322.     {$ENDC}
  323.  
  324. CONST
  325.     TweenComponentType            = 'twen';
  326.  
  327.  
  328. TYPE
  329.     TweenerComponent                    = ComponentInstance;
  330.     TweenRecordPtr = ^TweenRecord;
  331.     TweenerDataProcPtr = ProcPtr;  { FUNCTION TweenerData(VAR tr: TweenRecord; tweenData: UNIV Ptr; tweenDataSize: LONGINT; dataDescriptionSeed: LONGINT; dataDescription: Handle; asyncCompletionProc: ICMCompletionProcRecordPtr; transferProc: ProcPtr; refCon: UNIV Ptr): ComponentResult; }
  332.  
  333.     TweenerDataUPP = UniversalProcPtr;
  334.     TweenRecord = RECORD
  335.         version:                LONGINT;
  336.         container:                QTAtomContainer;
  337.         tweenAtom:                QTAtom;
  338.         dataAtom:                QTAtom;
  339.         percent:                Fixed;
  340.         dataProc:                TweenerDataUPP;
  341.         private1:                Ptr;
  342.         private2:                Ptr;
  343.     END;
  344.  
  345. FUNCTION TweenerInitialize(tc: TweenerComponent; container: QTAtomContainer; tweenAtom: QTAtom; dataAtom: QTAtom): ComponentResult;
  346.     {$IFC NOT GENERATINGCFM}
  347.     INLINE $2F3C, $000C, $0001, $7000, $A82A;
  348.     {$ENDC}
  349. FUNCTION TweenerDoTween(tc: TweenerComponent; VAR tr: TweenRecord): ComponentResult;
  350.     {$IFC NOT GENERATINGCFM}
  351.     INLINE $2F3C, $0004, $0002, $7000, $A82A;
  352.     {$ENDC}
  353. FUNCTION TweenerReset(tc: TweenerComponent): ComponentResult;
  354.     {$IFC NOT GENERATINGCFM}
  355.     INLINE $2F3C, $0000, $0003, $7000, $A82A;
  356.     {$ENDC}
  357.  
  358. CONST
  359.     TCSourceRefNameType            = 'name';
  360.  
  361.     tcDropFrame                    = $01;
  362.     tc24HourMax                    = $02;
  363.     tcNegTimesOK                = $04;
  364.     tcCounter                    = $08;
  365.  
  366.  
  367. TYPE
  368.     TimeCodeDefPtr = ^TimeCodeDef;
  369.     TimeCodeDef = RECORD
  370.         flags:                    LONGINT;                                {  drop-frame, etc. }
  371.         fTimeScale:                TimeScale;                                {  time scale of frameDuration (eg. 2997) }
  372.         frameDuration:            TimeValue;                                {  duration of each frame (eg. 100) }
  373.         numFrames:                SInt8;                                    {  frames/sec for timecode (eg. 30) OR frames/tick for counter mode }
  374.         padding:                SInt8;                                    {  unused padding byte }
  375.     END;
  376.  
  377.  
  378. CONST
  379.     tctNegFlag                    = $80;                            {  negative bit is in minutes }
  380.  
  381.  
  382. TYPE
  383.     TimeCodeTimePtr = ^TimeCodeTime;
  384.     TimeCodeTime = RECORD
  385.         hours:                    SInt8;
  386.         minutes:                SInt8;
  387.         seconds:                SInt8;
  388.         frames:                    SInt8;
  389.     END;
  390.  
  391.     TimeCodeCounterPtr = ^TimeCodeCounter;
  392.     TimeCodeCounter = RECORD
  393.         counter:                LONGINT;
  394.     END;
  395.  
  396.     TimeCodeRecordPtr = ^TimeCodeRecord;
  397.     TimeCodeRecord = RECORD
  398.         CASE INTEGER OF
  399.         0: (
  400.             t:                    TimeCodeTime;
  401.             );
  402.         1: (
  403.             c:                    TimeCodeCounter;
  404.             );
  405.     END;
  406.  
  407.     TimeCodeDescriptionPtr = ^TimeCodeDescription;
  408.     TimeCodeDescription = RECORD
  409.         descSize:                LONGINT;                                {  standard sample description header }
  410.         dataFormat:                LONGINT;
  411.         resvd1:                    LONGINT;
  412.         resvd2:                    INTEGER;
  413.         dataRefIndex:            INTEGER;
  414.         flags:                    LONGINT;                                {  timecode specific stuff }
  415.         timeCodeDef:            TimeCodeDef;
  416.         srcRef:                    ARRAY [0..0] OF LONGINT;
  417.     END;
  418.  
  419.     TimeCodeDescriptionHandle            = ^TimeCodeDescriptionPtr;
  420.  
  421. CONST
  422.     tcdfShowTimeCode            = $01;
  423.  
  424.  
  425. TYPE
  426.     TCTextOptionsPtr = ^TCTextOptions;
  427.     TCTextOptions = RECORD
  428.         txFont:                    INTEGER;
  429.         txFace:                    INTEGER;
  430.         txSize:                    INTEGER;
  431.         foreColor:                RGBColor;
  432.         backColor:                RGBColor;
  433.     END;
  434.  
  435. FUNCTION TCGetCurrentTimeCode(mh: MediaHandler; VAR frameNum: LONGINT; VAR tcdef: TimeCodeDef; VAR tcrec: TimeCodeRecord; VAR srcRefH: UserData): HandlerError;
  436.     {$IFC NOT GENERATINGCFM}
  437.     INLINE $2F3C, $0010, $0101, $7000, $A82A;
  438.     {$ENDC}
  439. FUNCTION TCGetTimeCodeAtTime(mh: MediaHandler; mediaTime: TimeValue; VAR frameNum: LONGINT; VAR tcdef: TimeCodeDef; VAR tcdata: TimeCodeRecord; VAR srcRefH: UserData): HandlerError;
  440.     {$IFC NOT GENERATINGCFM}
  441.     INLINE $2F3C, $0014, $0102, $7000, $A82A;
  442.     {$ENDC}
  443. FUNCTION TCTimeCodeToString(mh: MediaHandler; VAR tcdef: TimeCodeDef; VAR tcrec: TimeCodeRecord; tcStr: StringPtr): HandlerError;
  444.     {$IFC NOT GENERATINGCFM}
  445.     INLINE $2F3C, $000C, $0103, $7000, $A82A;
  446.     {$ENDC}
  447. FUNCTION TCTimeCodeToFrameNumber(mh: MediaHandler; VAR tcdef: TimeCodeDef; VAR tcrec: TimeCodeRecord; VAR frameNumber: LONGINT): HandlerError;
  448.     {$IFC NOT GENERATINGCFM}
  449.     INLINE $2F3C, $000C, $0104, $7000, $A82A;
  450.     {$ENDC}
  451. FUNCTION TCFrameNumberToTimeCode(mh: MediaHandler; frameNumber: LONGINT; VAR tcdef: TimeCodeDef; VAR tcrec: TimeCodeRecord): HandlerError;
  452.     {$IFC NOT GENERATINGCFM}
  453.     INLINE $2F3C, $000C, $0105, $7000, $A82A;
  454.     {$ENDC}
  455. FUNCTION TCGetSourceRef(mh: MediaHandler; tcdH: TimeCodeDescriptionHandle; VAR srefH: UserData): HandlerError;
  456.     {$IFC NOT GENERATINGCFM}
  457.     INLINE $2F3C, $0008, $0106, $7000, $A82A;
  458.     {$ENDC}
  459. FUNCTION TCSetSourceRef(mh: MediaHandler; tcdH: TimeCodeDescriptionHandle; srefH: UserData): HandlerError;
  460.     {$IFC NOT GENERATINGCFM}
  461.     INLINE $2F3C, $0008, $0107, $7000, $A82A;
  462.     {$ENDC}
  463. FUNCTION TCSetTimeCodeFlags(mh: MediaHandler; flags: LONGINT; flagsMask: LONGINT): HandlerError;
  464.     {$IFC NOT GENERATINGCFM}
  465.     INLINE $2F3C, $0008, $0108, $7000, $A82A;
  466.     {$ENDC}
  467. FUNCTION TCGetTimeCodeFlags(mh: MediaHandler; VAR flags: LONGINT): HandlerError;
  468.     {$IFC NOT GENERATINGCFM}
  469.     INLINE $2F3C, $0004, $0109, $7000, $A82A;
  470.     {$ENDC}
  471. FUNCTION TCSetDisplayOptions(mh: MediaHandler; textOptions: TCTextOptionsPtr): HandlerError;
  472.     {$IFC NOT GENERATINGCFM}
  473.     INLINE $2F3C, $0004, $010A, $7000, $A82A;
  474.     {$ENDC}
  475. FUNCTION TCGetDisplayOptions(mh: MediaHandler; textOptions: TCTextOptionsPtr): HandlerError;
  476.     {$IFC NOT GENERATINGCFM}
  477.     INLINE $2F3C, $0004, $010B, $7000, $A82A;
  478.     {$ENDC}
  479.  
  480. TYPE
  481.     MovieImportComponent                = ComponentInstance;
  482.     MovieExportComponent                = ComponentInstance;
  483.  
  484. CONST
  485.     MovieImportType                = 'eat ';
  486.     MovieExportType                = 'spit';
  487.  
  488.     canMovieImportHandles        = $01;
  489.     canMovieImportFiles            = $02;
  490.     hasMovieImportUserInterface    = $04;
  491.     canMovieExportHandles        = $08;
  492.     canMovieExportFiles            = $10;
  493.     hasMovieExportUserInterface    = $20;
  494.     dontAutoFileMovieImport        = $40;
  495.     canMovieExportAuxDataHandle    = $80;
  496.     canMovieImportValidateHandles = $0100;
  497.     canMovieImportValidateFile    = $0200;
  498.     dontRegisterWithEasyOpen    = $0400;
  499.     canMovieImportInPlace        = $0800;
  500.     movieImportSubTypeIsFileExtension = $1000;
  501.  
  502.     movieImportCreateTrack        = 1;
  503.     movieImportInParallel        = 2;
  504.     movieImportMustUseTrack        = 4;
  505.  
  506.     movieImportResultUsedMultipleTracks = 8;
  507.  
  508.     kMovieExportTextOnly        = 0;
  509.     kMovieExportAbsoluteTime    = 1;
  510.     kMovieExportRelativeTime    = 2;
  511.  
  512.     kMIDIImportSilenceBefore    = $01;
  513.     kMIDIImportSilenceAfter        = $02;
  514.     kMIDIImport20Playable        = $04;
  515.     kMIDIImportWantLyrics        = $08;
  516.  
  517. FUNCTION MovieImportHandle(ci: MovieImportComponent; dataH: Handle; theMovie: Movie; targetTrack: Track; VAR usedTrack: Track; atTime: TimeValue; VAR addedDuration: TimeValue; inFlags: LONGINT; VAR outFlags: LONGINT): ComponentResult;
  518.     {$IFC NOT GENERATINGCFM}
  519.     INLINE $2F3C, $0020, $0001, $7000, $A82A;
  520.     {$ENDC}
  521. FUNCTION MovieImportFile(ci: MovieImportComponent; {CONST}VAR theFile: FSSpec; theMovie: Movie; targetTrack: Track; VAR usedTrack: Track; atTime: TimeValue; VAR addedDuration: TimeValue; inFlags: LONGINT; VAR outFlags: LONGINT): ComponentResult;
  522.     {$IFC NOT GENERATINGCFM}
  523.     INLINE $2F3C, $0020, $0002, $7000, $A82A;
  524.     {$ENDC}
  525. FUNCTION MovieImportSetSampleDuration(ci: MovieImportComponent; duration: TimeValue; scale: TimeScale): ComponentResult;
  526.     {$IFC NOT GENERATINGCFM}
  527.     INLINE $2F3C, $0008, $0003, $7000, $A82A;
  528.     {$ENDC}
  529. FUNCTION MovieImportSetSampleDescription(ci: MovieImportComponent; desc: SampleDescriptionHandle; mediaType: OSType): ComponentResult;
  530.     {$IFC NOT GENERATINGCFM}
  531.     INLINE $2F3C, $0008, $0004, $7000, $A82A;
  532.     {$ENDC}
  533. FUNCTION MovieImportSetMediaFile(ci: MovieImportComponent; alias: AliasHandle): ComponentResult;
  534.     {$IFC NOT GENERATINGCFM}
  535.     INLINE $2F3C, $0004, $0005, $7000, $A82A;
  536.     {$ENDC}
  537. FUNCTION MovieImportSetDimensions(ci: MovieImportComponent; width: Fixed; height: Fixed): ComponentResult;
  538.     {$IFC NOT GENERATINGCFM}
  539.     INLINE $2F3C, $0008, $0006, $7000, $A82A;
  540.     {$ENDC}
  541. FUNCTION MovieImportSetChunkSize(ci: MovieImportComponent; chunkSize: LONGINT): ComponentResult;
  542.     {$IFC NOT GENERATINGCFM}
  543.     INLINE $2F3C, $0004, $0007, $7000, $A82A;
  544.     {$ENDC}
  545. FUNCTION MovieImportSetProgressProc(ci: MovieImportComponent; proc: MovieProgressUPP; refcon: LONGINT): ComponentResult;
  546.     {$IFC NOT GENERATINGCFM}
  547.     INLINE $2F3C, $0008, $0008, $7000, $A82A;
  548.     {$ENDC}
  549. FUNCTION MovieImportSetAuxiliaryData(ci: MovieImportComponent; data: Handle; handleType: OSType): ComponentResult;
  550.     {$IFC NOT GENERATINGCFM}
  551.     INLINE $2F3C, $0008, $0009, $7000, $A82A;
  552.     {$ENDC}
  553. FUNCTION MovieImportSetFromScrap(ci: MovieImportComponent; fromScrap: BOOLEAN): ComponentResult;
  554.     {$IFC NOT GENERATINGCFM}
  555.     INLINE $2F3C, $0002, $000A, $7000, $A82A;
  556.     {$ENDC}
  557. FUNCTION MovieImportDoUserDialog(ci: MovieImportComponent; {CONST}VAR theFile: FSSpec; theData: Handle; VAR canceled: BOOLEAN): ComponentResult;
  558.     {$IFC NOT GENERATINGCFM}
  559.     INLINE $2F3C, $000C, $000B, $7000, $A82A;
  560.     {$ENDC}
  561. FUNCTION MovieImportSetDuration(ci: MovieImportComponent; duration: TimeValue): ComponentResult;
  562.     {$IFC NOT GENERATINGCFM}
  563.     INLINE $2F3C, $0004, $000C, $7000, $A82A;
  564.     {$ENDC}
  565. FUNCTION MovieImportGetAuxiliaryDataType(ci: MovieImportComponent; VAR auxType: OSType): ComponentResult;
  566.     {$IFC NOT GENERATINGCFM}
  567.     INLINE $2F3C, $0004, $000D, $7000, $A82A;
  568.     {$ENDC}
  569. FUNCTION MovieImportValidate(ci: MovieImportComponent; {CONST}VAR theFile: FSSpec; theData: Handle; VAR valid: BOOLEAN): ComponentResult;
  570.     {$IFC NOT GENERATINGCFM}
  571.     INLINE $2F3C, $000C, $000E, $7000, $A82A;
  572.     {$ENDC}
  573. FUNCTION MovieImportGetFileType(ci: MovieImportComponent; VAR fileType: OSType): ComponentResult;
  574.     {$IFC NOT GENERATINGCFM}
  575.     INLINE $2F3C, $0004, $000F, $7000, $A82A;
  576.     {$ENDC}
  577. FUNCTION MovieImportDataRef(ci: MovieImportComponent; dataRef: Handle; dataRefType: OSType; theMovie: Movie; targetTrack: Track; VAR usedTrack: Track; atTime: TimeValue; VAR addedDuration: TimeValue; inFlags: LONGINT; VAR outFlags: LONGINT): ComponentResult;
  578.     {$IFC NOT GENERATINGCFM}
  579.     INLINE $2F3C, $0024, $0010, $7000, $A82A;
  580.     {$ENDC}
  581. FUNCTION MovieImportGetSampleDescription(ci: MovieImportComponent; VAR desc: SampleDescriptionHandle; VAR mediaType: OSType): ComponentResult;
  582.     {$IFC NOT GENERATINGCFM}
  583.     INLINE $2F3C, $0008, $0011, $7000, $A82A;
  584.     {$ENDC}
  585. FUNCTION MovieExportToHandle(ci: MovieExportComponent; dataH: Handle; theMovie: Movie; onlyThisTrack: Track; startTime: TimeValue; duration: TimeValue): ComponentResult;
  586.     {$IFC NOT GENERATINGCFM}
  587.     INLINE $2F3C, $0014, $0080, $7000, $A82A;
  588.     {$ENDC}
  589. FUNCTION MovieExportToFile(ci: MovieExportComponent; {CONST}VAR theFile: FSSpec; theMovie: Movie; onlyThisTrack: Track; startTime: TimeValue; duration: TimeValue): ComponentResult;
  590.     {$IFC NOT GENERATINGCFM}
  591.     INLINE $2F3C, $0014, $0081, $7000, $A82A;
  592.     {$ENDC}
  593. FUNCTION MovieExportGetAuxiliaryData(ci: MovieExportComponent; dataH: Handle; VAR handleType: OSType): ComponentResult;
  594.     {$IFC NOT GENERATINGCFM}
  595.     INLINE $2F3C, $0008, $0083, $7000, $A82A;
  596.     {$ENDC}
  597. FUNCTION MovieExportSetProgressProc(ci: MovieExportComponent; proc: MovieProgressUPP; refcon: LONGINT): ComponentResult;
  598.     {$IFC NOT GENERATINGCFM}
  599.     INLINE $2F3C, $0008, $0084, $7000, $A82A;
  600.     {$ENDC}
  601. FUNCTION MovieExportSetSampleDescription(ci: MovieExportComponent; desc: SampleDescriptionHandle; mediaType: OSType): ComponentResult;
  602.     {$IFC NOT GENERATINGCFM}
  603.     INLINE $2F3C, $0008, $0085, $7000, $A82A;
  604.     {$ENDC}
  605. FUNCTION MovieExportDoUserDialog(ci: MovieExportComponent; theMovie: Movie; onlyThisTrack: Track; startTime: TimeValue; duration: TimeValue; VAR canceled: BOOLEAN): ComponentResult;
  606.     {$IFC NOT GENERATINGCFM}
  607.     INLINE $2F3C, $0014, $0086, $7000, $A82A;
  608.     {$ENDC}
  609. FUNCTION MovieExportGetCreatorType(ci: MovieExportComponent; VAR creator: OSType): ComponentResult;
  610.     {$IFC NOT GENERATINGCFM}
  611.     INLINE $2F3C, $0004, $0087, $7000, $A82A;
  612.     {$ENDC}
  613. {  Text Export Display Info data structure }
  614.  
  615. TYPE
  616.     TextDisplayDataPtr = ^TextDisplayData;
  617.     TextDisplayData = RECORD
  618.         displayFlags:            LONGINT;
  619.         textJustification:        LONGINT;
  620.         bgColor:                RGBColor;
  621.         textBox:                Rect;
  622.         beginHilite:            INTEGER;
  623.         endHilite:                INTEGER;
  624.         hiliteColor:            RGBColor;
  625.         doHiliteColor:            BOOLEAN;
  626.         filler:                    SInt8;
  627.         scrollDelayDur:            TimeValue;
  628.         dropShadowOffset:        Point;
  629.         dropShadowTransparency:    INTEGER;
  630.     END;
  631.  
  632.     TextExportComponent                    = ComponentInstance;
  633. FUNCTION TextExportGetDisplayData(ci: TextExportComponent; VAR textDisplay: TextDisplayData): ComponentResult;
  634.     {$IFC NOT GENERATINGCFM}
  635.     INLINE $2F3C, $0004, $0100, $7000, $A82A;
  636.     {$ENDC}
  637. FUNCTION TextExportGetTimeFraction(ci: TextExportComponent; VAR movieTimeFraction: LONGINT): ComponentResult;
  638.     {$IFC NOT GENERATINGCFM}
  639.     INLINE $2F3C, $0004, $0101, $7000, $A82A;
  640.     {$ENDC}
  641. FUNCTION TextExportSetTimeFraction(ci: TextExportComponent; movieTimeFraction: LONGINT): ComponentResult;
  642.     {$IFC NOT GENERATINGCFM}
  643.     INLINE $2F3C, $0004, $0102, $7000, $A82A;
  644.     {$ENDC}
  645. FUNCTION TextExportGetSettings(ci: TextExportComponent; VAR setting: LONGINT): ComponentResult;
  646.     {$IFC NOT GENERATINGCFM}
  647.     INLINE $2F3C, $0004, $0103, $7000, $A82A;
  648.     {$ENDC}
  649. FUNCTION TextExportSetSettings(ci: TextExportComponent; setting: LONGINT): ComponentResult;
  650.     {$IFC NOT GENERATINGCFM}
  651.     INLINE $2F3C, $0004, $0104, $7000, $A82A;
  652.     {$ENDC}
  653. FUNCTION MIDIImportGetSettings(ci: TextExportComponent; VAR setting: LONGINT): ComponentResult;
  654.     {$IFC NOT GENERATINGCFM}
  655.     INLINE $2F3C, $0004, $0100, $7000, $A82A;
  656.     {$ENDC}
  657. FUNCTION MIDIImportSetSettings(ci: TextExportComponent; setting: LONGINT): ComponentResult;
  658.     {$IFC NOT GENERATINGCFM}
  659.     INLINE $2F3C, $0004, $0101, $7000, $A82A;
  660.     {$ENDC}
  661. {
  662. **************
  663.  
  664.     File Preview Components
  665.  
  666. **************
  667. }
  668.  
  669. TYPE
  670.     pnotComponent                        = ComponentInstance;
  671.  
  672. CONST
  673.     pnotComponentWantsEvents    = 1;
  674.     pnotComponentNeedsNoCache    = 2;
  675.  
  676.     ShowFilePreviewComponentType = 'pnot';
  677.     CreateFilePreviewComponentType = 'pmak';
  678.  
  679. FUNCTION PreviewShowData(p: pnotComponent; dataType: OSType; data: Handle; {CONST}VAR inHere: Rect): ComponentResult;
  680.     {$IFC NOT GENERATINGCFM}
  681.     INLINE $2F3C, $000C, $0001, $7000, $A82A;
  682.     {$ENDC}
  683. FUNCTION PreviewMakePreview(p: pnotComponent; VAR previewType: OSType; VAR previewResult: Handle; {CONST}VAR sourceFile: FSSpec; progress: ICMProgressProcRecordPtr): ComponentResult;
  684.     {$IFC NOT GENERATINGCFM}
  685.     INLINE $2F3C, $0010, $0002, $7000, $A82A;
  686.     {$ENDC}
  687. FUNCTION PreviewMakePreviewReference(p: pnotComponent; VAR previewType: OSType; VAR resID: INTEGER; {CONST}VAR sourceFile: FSSpec): ComponentResult;
  688.     {$IFC NOT GENERATINGCFM}
  689.     INLINE $2F3C, $000C, $0003, $7000, $A82A;
  690.     {$ENDC}
  691. FUNCTION PreviewEvent(p: pnotComponent; VAR e: EventRecord; VAR handledEvent: BOOLEAN): ComponentResult;
  692.     {$IFC NOT GENERATINGCFM}
  693.     INLINE $2F3C, $0008, $0004, $7000, $A82A;
  694.     {$ENDC}
  695.  
  696. TYPE
  697.     DataHCompletionProcPtr = ProcPtr;  { PROCEDURE DataHCompletion(request: Ptr; refcon: LONGINT; err: OSErr); }
  698.  
  699.     DataHCompletionUPP = UniversalProcPtr;
  700.  
  701. CONST
  702.     kDataHCanRead                = $00000001;
  703.     kDataHSpecialRead            = $00000002;
  704.     kDataHSpecialReadFile        = $00000004;
  705.     kDataHCanWrite                = $00000008;
  706.     kDataHSpecialWrite            = $10;
  707.     kDataHSpecialWriteFile        = $20;
  708.     kDataHCanStreamingWrite        = $40;
  709.     kDataHMustCheckDataRef        = $80;
  710.  
  711.  
  712. TYPE
  713.     DataHVolumeListRecordPtr = ^DataHVolumeListRecord;
  714.     DataHVolumeListRecord = RECORD
  715.         vRefNum:                INTEGER;
  716.         flags:                    LONGINT;
  717.     END;
  718.  
  719.     DataHVolumeListPtr                    = ^DataHVolumeListRecord;
  720.     DataHVolumeList                        = ^DataHVolumeListPtr;
  721.  
  722. CONST
  723.     kDataHExtendedSchedule        = 'xtnd';
  724.  
  725.  
  726. TYPE
  727.     DataHScheduleRecordPtr = ^DataHScheduleRecord;
  728.     DataHScheduleRecord = RECORD
  729.         timeNeededBy:            TimeRecord;
  730.         extendedID:                LONGINT;                                {  always is kDataHExtendedSchedule }
  731.         extendedVers:            LONGINT;                                {  always set to 0 }
  732.         priority:                Fixed;                                    {  100.0 or more means must have. lower numbers… }
  733.     END;
  734.  
  735.     DataHSchedulePtr                    = ^DataHScheduleRecord;
  736. FUNCTION DataHGetData(dh: DataHandler; h: Handle; hOffset: LONGINT; offset: LONGINT; size: LONGINT): ComponentResult;
  737.     {$IFC NOT GENERATINGCFM}
  738.     INLINE $2F3C, $0010, $0002, $7000, $A82A;
  739.     {$ENDC}
  740. FUNCTION DataHPutData(dh: DataHandler; h: Handle; hOffset: LONGINT; VAR offset: LONGINT; size: LONGINT): ComponentResult;
  741.     {$IFC NOT GENERATINGCFM}
  742.     INLINE $2F3C, $0010, $0003, $7000, $A82A;
  743.     {$ENDC}
  744. FUNCTION DataHFlushData(dh: DataHandler): ComponentResult;
  745.     {$IFC NOT GENERATINGCFM}
  746.     INLINE $2F3C, $0000, $0004, $7000, $A82A;
  747.     {$ENDC}
  748. FUNCTION DataHOpenForWrite(dh: DataHandler): ComponentResult;
  749.     {$IFC NOT GENERATINGCFM}
  750.     INLINE $2F3C, $0000, $0005, $7000, $A82A;
  751.     {$ENDC}
  752. FUNCTION DataHCloseForWrite(dh: DataHandler): ComponentResult;
  753.     {$IFC NOT GENERATINGCFM}
  754.     INLINE $2F3C, $0000, $0006, $7000, $A82A;
  755.     {$ENDC}
  756. FUNCTION DataHOpenForRead(dh: DataHandler): ComponentResult;
  757.     {$IFC NOT GENERATINGCFM}
  758.     INLINE $2F3C, $0000, $0008, $7000, $A82A;
  759.     {$ENDC}
  760. FUNCTION DataHCloseForRead(dh: DataHandler): ComponentResult;
  761.     {$IFC NOT GENERATINGCFM}
  762.     INLINE $2F3C, $0000, $0009, $7000, $A82A;
  763.     {$ENDC}
  764. FUNCTION DataHSetDataRef(dh: DataHandler; dataRef: Handle): ComponentResult;
  765.     {$IFC NOT GENERATINGCFM}
  766.     INLINE $2F3C, $0004, $000A, $7000, $A82A;
  767.     {$ENDC}
  768. FUNCTION DataHGetDataRef(dh: DataHandler; VAR dataRef: Handle): ComponentResult;
  769.     {$IFC NOT GENERATINGCFM}
  770.     INLINE $2F3C, $0004, $000B, $7000, $A82A;
  771.     {$ENDC}
  772. FUNCTION DataHCompareDataRef(dh: DataHandler; dataRef: Handle; VAR equal: BOOLEAN): ComponentResult;
  773.     {$IFC NOT GENERATINGCFM}
  774.     INLINE $2F3C, $0008, $000C, $7000, $A82A;
  775.     {$ENDC}
  776. FUNCTION DataHTask(dh: DataHandler): ComponentResult;
  777.     {$IFC NOT GENERATINGCFM}
  778.     INLINE $2F3C, $0000, $000D, $7000, $A82A;
  779.     {$ENDC}
  780. FUNCTION DataHScheduleData(dh: DataHandler; PlaceToPutDataPtr: Ptr; FileOffset: LONGINT; DataSize: LONGINT; RefCon: LONGINT; scheduleRec: DataHSchedulePtr; CompletionRtn: DataHCompletionUPP): ComponentResult;
  781.     {$IFC NOT GENERATINGCFM}
  782.     INLINE $2F3C, $0018, $000E, $7000, $A82A;
  783.     {$ENDC}
  784. FUNCTION DataHFinishData(dh: DataHandler; PlaceToPutDataPtr: Ptr; Cancel: BOOLEAN): ComponentResult;
  785.     {$IFC NOT GENERATINGCFM}
  786.     INLINE $2F3C, $0006, $000F, $7000, $A82A;
  787.     {$ENDC}
  788. FUNCTION DataHFlushCache(dh: DataHandler): ComponentResult;
  789.     {$IFC NOT GENERATINGCFM}
  790.     INLINE $2F3C, $0000, $0010, $7000, $A82A;
  791.     {$ENDC}
  792. FUNCTION DataHResolveDataRef(dh: DataHandler; theDataRef: Handle; VAR wasChanged: BOOLEAN; userInterfaceAllowed: BOOLEAN): ComponentResult;
  793.     {$IFC NOT GENERATINGCFM}
  794.     INLINE $2F3C, $000A, $0011, $7000, $A82A;
  795.     {$ENDC}
  796. FUNCTION DataHGetFileSize(dh: DataHandler; VAR fileSize: LONGINT): ComponentResult;
  797.     {$IFC NOT GENERATINGCFM}
  798.     INLINE $2F3C, $0004, $0012, $7000, $A82A;
  799.     {$ENDC}
  800. FUNCTION DataHCanUseDataRef(dh: DataHandler; dataRef: Handle; VAR useFlags: LONGINT): ComponentResult;
  801.     {$IFC NOT GENERATINGCFM}
  802.     INLINE $2F3C, $0008, $0013, $7000, $A82A;
  803.     {$ENDC}
  804. FUNCTION DataHGetVolumeList(dh: DataHandler; VAR volumeList: DataHVolumeList): ComponentResult;
  805.     {$IFC NOT GENERATINGCFM}
  806.     INLINE $2F3C, $0004, $0014, $7000, $A82A;
  807.     {$ENDC}
  808. FUNCTION DataHWrite(dh: DataHandler; data: Ptr; offset: LONGINT; size: LONGINT; completion: DataHCompletionUPP; refCon: LONGINT): ComponentResult;
  809.     {$IFC NOT GENERATINGCFM}
  810.     INLINE $2F3C, $0014, $0015, $7000, $A82A;
  811.     {$ENDC}
  812. FUNCTION DataHPreextend(dh: DataHandler; maxToAdd: LONGINT; VAR spaceAdded: LONGINT): ComponentResult;
  813.     {$IFC NOT GENERATINGCFM}
  814.     INLINE $2F3C, $0008, $0016, $7000, $A82A;
  815.     {$ENDC}
  816. FUNCTION DataHSetFileSize(dh: DataHandler; fileSize: LONGINT): ComponentResult;
  817.     {$IFC NOT GENERATINGCFM}
  818.     INLINE $2F3C, $0004, $0017, $7000, $A82A;
  819.     {$ENDC}
  820. FUNCTION DataHGetFreeSpace(dh: DataHandler; VAR freeSize: LONGINT): ComponentResult;
  821.     {$IFC NOT GENERATINGCFM}
  822.     INLINE $2F3C, $0004, $0018, $7000, $A82A;
  823.     {$ENDC}
  824. FUNCTION DataHCreateFile(dh: DataHandler; creator: OSType; deleteExisting: BOOLEAN): ComponentResult;
  825.     {$IFC NOT GENERATINGCFM}
  826.     INLINE $2F3C, $0006, $0019, $7000, $A82A;
  827.     {$ENDC}
  828. FUNCTION DataHGetPreferredBlockSize(dh: DataHandler; VAR blockSize: LONGINT): ComponentResult;
  829.     {$IFC NOT GENERATINGCFM}
  830.     INLINE $2F3C, $0004, $001A, $7000, $A82A;
  831.     {$ENDC}
  832. FUNCTION DataHGetDeviceIndex(dh: DataHandler; VAR deviceIndex: LONGINT): ComponentResult;
  833.     {$IFC NOT GENERATINGCFM}
  834.     INLINE $2F3C, $0004, $001B, $7000, $A82A;
  835.     {$ENDC}
  836. FUNCTION DataHIsStreamingDataHandler(dh: DataHandler; VAR yes: BOOLEAN): ComponentResult;
  837.     {$IFC NOT GENERATINGCFM}
  838.     INLINE $2F3C, $0004, $001C, $7000, $A82A;
  839.     {$ENDC}
  840. FUNCTION DataHGetDataInBuffer(dh: DataHandler; startOffset: LONGINT; VAR size: LONGINT): ComponentResult;
  841.     {$IFC NOT GENERATINGCFM}
  842.     INLINE $2F3C, $0008, $001D, $7000, $A82A;
  843.     {$ENDC}
  844. FUNCTION DataHGetScheduleAheadTime(dh: DataHandler; VAR millisecs: LONGINT): ComponentResult;
  845.     {$IFC NOT GENERATINGCFM}
  846.     INLINE $2F3C, $0004, $001E, $7000, $A82A;
  847.     {$ENDC}
  848. FUNCTION DataHSetCacheSizeLimit(dh: DataHandler; cacheSizeLimit: Size): ComponentResult;
  849.     {$IFC NOT GENERATINGCFM}
  850.     INLINE $2F3C, $0004, $001F, $7000, $A82A;
  851.     {$ENDC}
  852. FUNCTION DataHGetCacheSizeLimit(dh: DataHandler; VAR cacheSizeLimit: Size): ComponentResult;
  853.     {$IFC NOT GENERATINGCFM}
  854.     INLINE $2F3C, $0004, $0020, $7000, $A82A;
  855.     {$ENDC}
  856. FUNCTION DataHGetMovie(dh: DataHandler; VAR theMovie: Movie; VAR id: INTEGER): ComponentResult;
  857.     {$IFC NOT GENERATINGCFM}
  858.     INLINE $2F3C, $0008, $0021, $7000, $A82A;
  859.     {$ENDC}
  860. FUNCTION DataHAddMovie(dh: DataHandler; theMovie: Movie; VAR id: INTEGER): ComponentResult;
  861.     {$IFC NOT GENERATINGCFM}
  862.     INLINE $2F3C, $0008, $0022, $7000, $A82A;
  863.     {$ENDC}
  864. FUNCTION DataHUpdateMovie(dh: DataHandler; theMovie: Movie; id: INTEGER): ComponentResult;
  865.     {$IFC NOT GENERATINGCFM}
  866.     INLINE $2F3C, $0006, $0023, $7000, $A82A;
  867.     {$ENDC}
  868. FUNCTION DataHDoesBuffer(dh: DataHandler; VAR buffersReads: BOOLEAN; VAR buffersWrites: BOOLEAN): ComponentResult;
  869.     {$IFC NOT GENERATINGCFM}
  870.     INLINE $2F3C, $0008, $0024, $7000, $A82A;
  871.     {$ENDC}
  872. FUNCTION DataHGetFileName(dh: DataHandler; VAR str: Str255): ComponentResult;
  873.     {$IFC NOT GENERATINGCFM}
  874.     INLINE $2F3C, $0004, $0025, $7000, $A82A;
  875.     {$ENDC}
  876. FUNCTION DataHPlaybackHints(dh: DataHandler; flags: LONGINT; minFileOffset: LONGINT; maxFileOffset: LONGINT; bytesPerSecond: LONGINT): ComponentResult;
  877.     {$IFC NOT GENERATINGCFM}
  878.     INLINE $2F3C, $0010, $0103, $7000, $A82A;
  879.     {$ENDC}
  880. {  Standard type for video digitizers  }
  881.  
  882. CONST
  883.     videoDigitizerComponentType    = 'vdig';
  884.     vdigInterfaceRev            = 2;
  885.  
  886. {  Input Format Standards  }
  887.     ntscIn                        = 0;                            {  current input format  }
  888.     currentIn                    = 0;                            {  ntsc input format  }
  889.     palIn                        = 1;                            {  pal input format  }
  890.     secamIn                        = 2;                            {  secam input format  }
  891.     ntscReallyIn                = 3;                            {  ntsc input format  }
  892.  
  893. {  Input Formats  }
  894.     compositeIn                    = 0;                            {  input is composite format  }
  895.     sVideoIn                    = 1;                            {  input is sVideo format  }
  896.     rgbComponentIn                = 2;                            {  input is rgb component format  }
  897.     rgbComponentSyncIn            = 3;                            {  input is rgb component format (sync on green?) }
  898.     yuvComponentIn                = 4;                            {  input is yuv component format  }
  899.     yuvComponentSyncIn            = 5;                            {  input is yuv component format (sync on green?)  }
  900.     tvTunerIn                    = 6;
  901.  
  902. {  Video Digitizer PlayThru States  }
  903.     vdPlayThruOff                = 0;
  904.     vdPlayThruOn                = 1;
  905.  
  906. {  Input Color Space Modes  }
  907.     vdDigitizerBW                = 0;                            {  black and white  }
  908.     vdDigitizerRGB                = 1;                            {  rgb color  }
  909.  
  910. {  Phase Lock Loop Modes  }
  911.     vdBroadcastMode                = 0;                            {  Broadcast / Laser Disk video mode  }
  912.     vdVTRMode                    = 1;                            {  VCR / Magnetic media mode  }
  913.  
  914. {  Field Select Options  }
  915.     vdUseAnyField                = 0;                            {  Digitizers choice on field use  }
  916.     vdUseOddField                = 1;                            {  Use odd field for half size vert and smaller  }
  917.     vdUseEvenField                = 2;                            {  Use even field for half size vert and smaller  }
  918.  
  919. {  vdig types  }
  920.     vdTypeBasic                    = 0;                            {  basic, no clipping  }
  921.     vdTypeAlpha                    = 1;                            {  supports clipping with alpha channel  }
  922.     vdTypeMask                    = 2;                            {  supports clipping with mask plane  }
  923.     vdTypeKey                    = 3;                            {  supports clipping with key color(s)  }
  924.  
  925. {  Digitizer Input Capability/Current Flags     }
  926.     digiInDoesNTSC                = $00000001;                    {  digitizer supports NTSC input format  }
  927.     digiInDoesPAL                = $00000002;                    {  digitizer supports PAL input format  }
  928.     digiInDoesSECAM                = $00000004;                    {  digitizer supports SECAM input format  }
  929.     digiInDoesGenLock            = $00000080;                    {  digitizer does genlock  }
  930.     digiInDoesComposite            = $00000100;                    {  digitizer supports composite input type  }
  931.     digiInDoesSVideo            = $00000200;                    {  digitizer supports S-Video input type  }
  932.     digiInDoesComponent            = $00000400;                    {  digitizer supports component = rgb, input type  }
  933.     digiInVTR_Broadcast            = $00000800;                    {  digitizer can differentiate between the two  }
  934.     digiInDoesColor                = $00001000;                    {  digitizer supports color  }
  935.     digiInDoesBW                = $00002000;                    {  digitizer supports black & white  }
  936.                                                                 {  Digitizer Input Current Flags = these are valid only during active operating conditions,     }
  937.     digiInSignalLock            = $80000000;                    {  digitizer detects input signal is locked, this bit = horiz lock || vertical lock  }
  938.  
  939. {  Digitizer Output Capability/Current Flags  }
  940.     digiOutDoes1                = $00000001;                    {  digitizer supports 1 bit pixels  }
  941.     digiOutDoes2                = $00000002;                    {  digitizer supports 2 bit pixels  }
  942.     digiOutDoes4                = $00000004;                    {  digitizer supports 4 bit pixels  }
  943.     digiOutDoes8                = $00000008;                    {  digitizer supports 8 bit pixels  }
  944.     digiOutDoes16                = $00000010;                    {  digitizer supports 16 bit pixels  }
  945.     digiOutDoes32                = $00000020;                    {  digitizer supports 32 bit pixels  }
  946.     digiOutDoesDither            = $00000040;                    {  digitizer dithers in indexed modes  }
  947.     digiOutDoesStretch            = $00000080;                    {  digitizer can arbitrarily stretch  }
  948.     digiOutDoesShrink            = $00000100;                    {  digitizer can arbitrarily shrink  }
  949.     digiOutDoesMask                = $00000200;                    {  digitizer can mask to clipping regions  }
  950.     digiOutDoesDouble            = $00000800;                    {  digitizer can stretch to exactly double size  }
  951.     digiOutDoesQuad                = $00001000;                    {  digitizer can stretch exactly quadruple size  }
  952.     digiOutDoesQuarter            = $00002000;                    {  digitizer can shrink to exactly quarter size  }
  953.     digiOutDoesSixteenth        = $00004000;                    {  digitizer can shrink to exactly sixteenth size  }
  954.     digiOutDoesRotate            = $00008000;                    {  digitizer supports rotate transformations  }
  955.     digiOutDoesHorizFlip        = $00010000;                    {  digitizer supports horizontal flips Sx < 0  }
  956.     digiOutDoesVertFlip            = $00020000;                    {  digitizer supports vertical flips Sy < 0  }
  957.     digiOutDoesSkew                = $00040000;                    {  digitizer supports skew = shear,twist,  }
  958.     digiOutDoesBlend            = $00080000;
  959.     digiOutDoesWarp                = $00100000;
  960.     digiOutDoesHW_DMA            = $00200000;                    {  digitizer not constrained to local device  }
  961.     digiOutDoesHWPlayThru        = $00400000;                    {  digitizer doesn't need time to play thru  }
  962.     digiOutDoesILUT                = $00800000;                    {  digitizer does inverse LUT for index modes  }
  963.     digiOutDoesKeyColor            = $01000000;                    {  digitizer does key color functions too  }
  964.     digiOutDoesAsyncGrabs        = $02000000;                    {  digitizer supports async grabs  }
  965.     digiOutDoesUnreadableScreenBits = $04000000;                {  playthru doesn't generate readable bits on screen }
  966.     digiOutDoesCompress            = $08000000;                    {  supports alternate output data types  }
  967.     digiOutDoesCompressOnly        = $10000000;                    {  can't provide raw frames anywhere  }
  968.     digiOutDoesPlayThruDuringCompress = $20000000;                {  digi can do playthru while providing compressed data  }
  969.     digiOutDoesCompressPartiallyVisible = $40000000;            {  digi doesn't need all bits visible on screen to do hardware compress  }
  970.  
  971. {  Types  }
  972.  
  973. TYPE
  974.     VideoDigitizerComponent                = ComponentInstance;
  975.     VideoDigitizerError                    = ComponentResult;
  976.     DigitizerInfoPtr = ^DigitizerInfo;
  977.     DigitizerInfo = RECORD
  978.         vdigType:                INTEGER;
  979.         inputCapabilityFlags:    LONGINT;
  980.         outputCapabilityFlags:    LONGINT;
  981.         inputCurrentFlags:        LONGINT;
  982.         outputCurrentFlags:        LONGINT;
  983.         slot:                    INTEGER;                                {  temporary for connection purposes  }
  984.         gdh:                    GDHandle;                                {  temporary for digitizers that have preferred screen  }
  985.         maskgdh:                GDHandle;                                {  temporary for digitizers that have mask planes  }
  986.         minDestHeight:            INTEGER;                                {  Smallest resizable height  }
  987.         minDestWidth:            INTEGER;                                {  Smallest resizable width  }
  988.         maxDestHeight:            INTEGER;                                {  Largest resizable height  }
  989.         maxDestWidth:            INTEGER;                                {  Largest resizable height  }
  990.         blendLevels:            INTEGER;                                {  Number of blend levels supported (2 if 1 bit mask)  }
  991.         reserved:                LONGINT;                                {  reserved  }
  992.     END;
  993.  
  994.     VdigTypePtr = ^VdigType;
  995.     VdigType = RECORD
  996.         digType:                LONGINT;
  997.         reserved:                LONGINT;
  998.     END;
  999.  
  1000.     VdigTypeListPtr = ^VdigTypeList;
  1001.     VdigTypeList = RECORD
  1002.         count:                    INTEGER;
  1003.         list:                    ARRAY [0..0] OF VdigType;
  1004.     END;
  1005.  
  1006.     VdigBufferRecPtr = ^VdigBufferRec;
  1007.     VdigBufferRec = RECORD
  1008.         dest:                    PixMapHandle;
  1009.         location:                Point;
  1010.         reserved:                LONGINT;
  1011.     END;
  1012.  
  1013.     VdigBufferRecListPtr = ^VdigBufferRecList;
  1014.     VdigBufferRecList = RECORD
  1015.         count:                    INTEGER;
  1016.         matrix:                    MatrixRecordPtr;
  1017.         mask:                    RgnHandle;
  1018.         list:                    ARRAY [0..0] OF VdigBufferRec;
  1019.     END;
  1020.  
  1021.     VdigBufferRecListHandle                = ^VdigBufferRecListPtr;
  1022.     VdigIntProcPtr = ProcPtr;  { PROCEDURE VdigInt(flags: LONGINT; refcon: LONGINT); }
  1023.  
  1024.     VdigIntUPP = UniversalProcPtr;
  1025.     VDCompressionListPtr = ^VDCompressionList;
  1026.     VDCompressionList = RECORD
  1027.         codec:                    CodecComponent;
  1028.         cType:                    CodecType;
  1029.         typeName:                Str63;
  1030.         name:                    Str63;
  1031.         formatFlags:            LONGINT;
  1032.         compressFlags:            LONGINT;
  1033.         reserved:                LONGINT;
  1034.     END;
  1035.  
  1036.     VDCompressionListHandle                = ^VDCompressionListPtr;
  1037.  
  1038. CONST
  1039.     dmaDepth1                    = 1;
  1040.     dmaDepth2                    = 2;
  1041.     dmaDepth4                    = 4;
  1042.     dmaDepth8                    = 8;
  1043.     dmaDepth16                    = 16;
  1044.     dmaDepth32                    = 32;
  1045.     dmaDepth2Gray                = 64;
  1046.     dmaDepth4Gray                = 128;
  1047.     dmaDepth8Gray                = 256;
  1048.  
  1049.     kVDIGControlledFrameRate    = -1;
  1050.  
  1051. FUNCTION VDGetMaxSrcRect(ci: VideoDigitizerComponent; inputStd: INTEGER; VAR maxSrcRect: Rect): VideoDigitizerError;
  1052.     {$IFC NOT GENERATINGCFM}
  1053.     INLINE $2F3C, $0006, $0001, $7000, $A82A;
  1054.     {$ENDC}
  1055. FUNCTION VDGetActiveSrcRect(ci: VideoDigitizerComponent; inputStd: INTEGER; VAR activeSrcRect: Rect): VideoDigitizerError;
  1056.     {$IFC NOT GENERATINGCFM}
  1057.     INLINE $2F3C, $0006, $0002, $7000, $A82A;
  1058.     {$ENDC}
  1059. FUNCTION VDSetDigitizerRect(ci: VideoDigitizerComponent; VAR digitizerRect: Rect): VideoDigitizerError;
  1060.     {$IFC NOT GENERATINGCFM}
  1061.     INLINE $2F3C, $0004, $0003, $7000, $A82A;
  1062.     {$ENDC}
  1063. FUNCTION VDGetDigitizerRect(ci: VideoDigitizerComponent; VAR digitizerRect: Rect): VideoDigitizerError;
  1064.     {$IFC NOT GENERATINGCFM}
  1065.     INLINE $2F3C, $0004, $0004, $7000, $A82A;
  1066.     {$ENDC}
  1067. FUNCTION VDGetVBlankRect(ci: VideoDigitizerComponent; inputStd: INTEGER; VAR vBlankRect: Rect): VideoDigitizerError;
  1068.     {$IFC NOT GENERATINGCFM}
  1069.     INLINE $2F3C, $0006, $0005, $7000, $A82A;
  1070.     {$ENDC}
  1071. FUNCTION VDGetMaskPixMap(ci: VideoDigitizerComponent; maskPixMap: PixMapHandle): VideoDigitizerError;
  1072.     {$IFC NOT GENERATINGCFM}
  1073.     INLINE $2F3C, $0004, $0006, $7000, $A82A;
  1074.     {$ENDC}
  1075. FUNCTION VDGetPlayThruDestination(ci: VideoDigitizerComponent; VAR dest: PixMapHandle; VAR destRect: Rect; VAR m: MatrixRecord; VAR mask: RgnHandle): VideoDigitizerError;
  1076.     {$IFC NOT GENERATINGCFM}
  1077.     INLINE $2F3C, $0010, $0008, $7000, $A82A;
  1078.     {$ENDC}
  1079. FUNCTION VDUseThisCLUT(ci: VideoDigitizerComponent; colorTableHandle: CTabHandle): VideoDigitizerError;
  1080.     {$IFC NOT GENERATINGCFM}
  1081.     INLINE $2F3C, $0004, $0009, $7000, $A82A;
  1082.     {$ENDC}
  1083. FUNCTION VDSetInputGammaValue(ci: VideoDigitizerComponent; channel1: Fixed; channel2: Fixed; channel3: Fixed): VideoDigitizerError;
  1084.     {$IFC NOT GENERATINGCFM}
  1085.     INLINE $2F3C, $000C, $000A, $7000, $A82A;
  1086.     {$ENDC}
  1087. FUNCTION VDGetInputGammaValue(ci: VideoDigitizerComponent; VAR channel1: Fixed; VAR channel2: Fixed; VAR channel3: Fixed): VideoDigitizerError;
  1088.     {$IFC NOT GENERATINGCFM}
  1089.     INLINE $2F3C, $000C, $000B, $7000, $A82A;
  1090.     {$ENDC}
  1091. FUNCTION VDSetBrightness(ci: VideoDigitizerComponent; VAR brightness: INTEGER): VideoDigitizerError;
  1092.     {$IFC NOT GENERATINGCFM}
  1093.     INLINE $2F3C, $0004, $000C, $7000, $A82A;
  1094.     {$ENDC}
  1095. FUNCTION VDGetBrightness(ci: VideoDigitizerComponent; VAR brightness: INTEGER): VideoDigitizerError;
  1096.     {$IFC NOT GENERATINGCFM}
  1097.     INLINE $2F3C, $0004, $000D, $7000, $A82A;
  1098.     {$ENDC}
  1099. FUNCTION VDSetContrast(ci: VideoDigitizerComponent; VAR contrast: INTEGER): VideoDigitizerError;
  1100.     {$IFC NOT GENERATINGCFM}
  1101.     INLINE $2F3C, $0004, $000E, $7000, $A82A;
  1102.     {$ENDC}
  1103. FUNCTION VDSetHue(ci: VideoDigitizerComponent; VAR hue: INTEGER): VideoDigitizerError;
  1104.     {$IFC NOT GENERATINGCFM}
  1105.     INLINE $2F3C, $0004, $000F, $7000, $A82A;
  1106.     {$ENDC}
  1107. FUNCTION VDSetSharpness(ci: VideoDigitizerComponent; VAR sharpness: INTEGER): VideoDigitizerError;
  1108.     {$IFC NOT GENERATINGCFM}
  1109.     INLINE $2F3C, $0004, $0010, $7000, $A82A;
  1110.     {$ENDC}
  1111. FUNCTION VDSetSaturation(ci: VideoDigitizerComponent; VAR saturation: INTEGER): VideoDigitizerError;
  1112.     {$IFC NOT GENERATINGCFM}
  1113.     INLINE $2F3C, $0004, $0011, $7000, $A82A;
  1114.     {$ENDC}
  1115. FUNCTION VDGetContrast(ci: VideoDigitizerComponent; VAR contrast: INTEGER): VideoDigitizerError;
  1116.     {$IFC NOT GENERATINGCFM}
  1117.     INLINE $2F3C, $0004, $0012, $7000, $A82A;
  1118.     {$ENDC}
  1119. FUNCTION VDGetHue(ci: VideoDigitizerComponent; VAR hue: INTEGER): VideoDigitizerError;
  1120.     {$IFC NOT GENERATINGCFM}
  1121.     INLINE $2F3C, $0004, $0013, $7000, $A82A;
  1122.     {$ENDC}
  1123. FUNCTION VDGetSharpness(ci: VideoDigitizerComponent; VAR sharpness: INTEGER): VideoDigitizerError;
  1124.     {$IFC NOT GENERATINGCFM}
  1125.     INLINE $2F3C, $0004, $0014, $7000, $A82A;
  1126.     {$ENDC}
  1127. FUNCTION VDGetSaturation(ci: VideoDigitizerComponent; VAR saturation: INTEGER): VideoDigitizerError;
  1128.     {$IFC NOT GENERATINGCFM}
  1129.     INLINE $2F3C, $0004, $0015, $7000, $A82A;
  1130.     {$ENDC}
  1131. FUNCTION VDGrabOneFrame(ci: VideoDigitizerComponent): VideoDigitizerError;
  1132.     {$IFC NOT GENERATINGCFM}
  1133.     INLINE $2F3C, $0000, $0016, $7000, $A82A;
  1134.     {$ENDC}
  1135. FUNCTION VDGetMaxAuxBuffer(ci: VideoDigitizerComponent; VAR pm: PixMapHandle; VAR r: Rect): VideoDigitizerError;
  1136.     {$IFC NOT GENERATINGCFM}
  1137.     INLINE $2F3C, $0008, $0017, $7000, $A82A;
  1138.     {$ENDC}
  1139. FUNCTION VDGetDigitizerInfo(ci: VideoDigitizerComponent; VAR info: DigitizerInfo): VideoDigitizerError;
  1140.     {$IFC NOT GENERATINGCFM}
  1141.     INLINE $2F3C, $0004, $0019, $7000, $A82A;
  1142.     {$ENDC}
  1143. FUNCTION VDGetCurrentFlags(ci: VideoDigitizerComponent; VAR inputCurrentFlag: LONGINT; VAR outputCurrentFlag: LONGINT): VideoDigitizerError;
  1144.     {$IFC NOT GENERATINGCFM}
  1145.     INLINE $2F3C, $0008, $001A, $7000, $A82A;
  1146.     {$ENDC}
  1147. FUNCTION VDSetKeyColor(ci: VideoDigitizerComponent; index: LONGINT): VideoDigitizerError;
  1148.     {$IFC NOT GENERATINGCFM}
  1149.     INLINE $2F3C, $0004, $001B, $7000, $A82A;
  1150.     {$ENDC}
  1151. FUNCTION VDGetKeyColor(ci: VideoDigitizerComponent; VAR index: LONGINT): VideoDigitizerError;
  1152.     {$IFC NOT GENERATINGCFM}
  1153.     INLINE $2F3C, $0004, $001C, $7000, $A82A;
  1154.     {$ENDC}
  1155. FUNCTION VDAddKeyColor(ci: VideoDigitizerComponent; VAR index: LONGINT): VideoDigitizerError;
  1156.     {$IFC NOT GENERATINGCFM}
  1157.     INLINE $2F3C, $0004, $001D, $7000, $A82A;
  1158.     {$ENDC}
  1159. FUNCTION VDGetNextKeyColor(ci: VideoDigitizerComponent; index: LONGINT): VideoDigitizerError;
  1160.     {$IFC NOT GENERATINGCFM}
  1161.     INLINE $2F3C, $0004, $001E, $7000, $A82A;
  1162.     {$ENDC}
  1163. FUNCTION VDSetKeyColorRange(ci: VideoDigitizerComponent; VAR minRGB: RGBColor; VAR maxRGB: RGBColor): VideoDigitizerError;
  1164.     {$IFC NOT GENERATINGCFM}
  1165.     INLINE $2F3C, $0008, $001F, $7000, $A82A;
  1166.     {$ENDC}
  1167. FUNCTION VDGetKeyColorRange(ci: VideoDigitizerComponent; VAR minRGB: RGBColor; VAR maxRGB: RGBColor): VideoDigitizerError;
  1168.     {$IFC NOT GENERATINGCFM}
  1169.     INLINE $2F3C, $0008, $0020, $7000, $A82A;
  1170.     {$ENDC}
  1171. FUNCTION VDSetDigitizerUserInterrupt(ci: VideoDigitizerComponent; flags: LONGINT; userInterruptProc: VdigIntUPP; refcon: LONGINT): VideoDigitizerError;
  1172.     {$IFC NOT GENERATINGCFM}
  1173.     INLINE $2F3C, $000C, $0021, $7000, $A82A;
  1174.     {$ENDC}
  1175. FUNCTION VDSetInputColorSpaceMode(ci: VideoDigitizerComponent; colorSpaceMode: INTEGER): VideoDigitizerError;
  1176.     {$IFC NOT GENERATINGCFM}
  1177.     INLINE $2F3C, $0002, $0022, $7000, $A82A;
  1178.     {$ENDC}
  1179. FUNCTION VDGetInputColorSpaceMode(ci: VideoDigitizerComponent; VAR colorSpaceMode: INTEGER): VideoDigitizerError;
  1180.     {$IFC NOT GENERATINGCFM}
  1181.     INLINE $2F3C, $0004, $0023, $7000, $A82A;
  1182.     {$ENDC}
  1183. FUNCTION VDSetClipState(ci: VideoDigitizerComponent; clipEnable: INTEGER): VideoDigitizerError;
  1184.     {$IFC NOT GENERATINGCFM}
  1185.     INLINE $2F3C, $0002, $0024, $7000, $A82A;
  1186.     {$ENDC}
  1187. FUNCTION VDGetClipState(ci: VideoDigitizerComponent; VAR clipEnable: INTEGER): VideoDigitizerError;
  1188.     {$IFC NOT GENERATINGCFM}
  1189.     INLINE $2F3C, $0004, $0025, $7000, $A82A;
  1190.     {$ENDC}
  1191. FUNCTION VDSetClipRgn(ci: VideoDigitizerComponent; clipRegion: RgnHandle): VideoDigitizerError;
  1192.     {$IFC NOT GENERATINGCFM}
  1193.     INLINE $2F3C, $0004, $0026, $7000, $A82A;
  1194.     {$ENDC}
  1195. FUNCTION VDClearClipRgn(ci: VideoDigitizerComponent; clipRegion: RgnHandle): VideoDigitizerError;
  1196.     {$IFC NOT GENERATINGCFM}
  1197.     INLINE $2F3C, $0004, $0027, $7000, $A82A;
  1198.     {$ENDC}
  1199. FUNCTION VDGetCLUTInUse(ci: VideoDigitizerComponent; VAR colorTableHandle: CTabHandle): VideoDigitizerError;
  1200.     {$IFC NOT GENERATINGCFM}
  1201.     INLINE $2F3C, $0004, $0028, $7000, $A82A;
  1202.     {$ENDC}
  1203. FUNCTION VDSetPLLFilterType(ci: VideoDigitizerComponent; pllType: INTEGER): VideoDigitizerError;
  1204.     {$IFC NOT GENERATINGCFM}
  1205.     INLINE $2F3C, $0002, $0029, $7000, $A82A;
  1206.     {$ENDC}
  1207. FUNCTION VDGetPLLFilterType(ci: VideoDigitizerComponent; VAR pllType: INTEGER): VideoDigitizerError;
  1208.     {$IFC NOT GENERATINGCFM}
  1209.     INLINE $2F3C, $0004, $002A, $7000, $A82A;
  1210.     {$ENDC}
  1211. FUNCTION VDGetMaskandValue(ci: VideoDigitizerComponent; blendLevel: INTEGER; VAR mask: LONGINT; VAR value: LONGINT): VideoDigitizerError;
  1212.     {$IFC NOT GENERATINGCFM}
  1213.     INLINE $2F3C, $000A, $002B, $7000, $A82A;
  1214.     {$ENDC}
  1215. FUNCTION VDSetMasterBlendLevel(ci: VideoDigitizerComponent; VAR blendLevel: INTEGER): VideoDigitizerError;
  1216.     {$IFC NOT GENERATINGCFM}
  1217.     INLINE $2F3C, $0004, $002C, $7000, $A82A;
  1218.     {$ENDC}
  1219. FUNCTION VDSetPlayThruDestination(ci: VideoDigitizerComponent; dest: PixMapHandle; VAR destRect: Rect; VAR m: MatrixRecord; mask: RgnHandle): VideoDigitizerError;
  1220.     {$IFC NOT GENERATINGCFM}
  1221.     INLINE $2F3C, $0010, $002D, $7000, $A82A;
  1222.     {$ENDC}
  1223. FUNCTION VDSetPlayThruOnOff(ci: VideoDigitizerComponent; state: INTEGER): VideoDigitizerError;
  1224.     {$IFC NOT GENERATINGCFM}
  1225.     INLINE $2F3C, $0002, $002E, $7000, $A82A;
  1226.     {$ENDC}
  1227. FUNCTION VDSetFieldPreference(ci: VideoDigitizerComponent; fieldFlag: INTEGER): VideoDigitizerError;
  1228.     {$IFC NOT GENERATINGCFM}
  1229.     INLINE $2F3C, $0002, $002F, $7000, $A82A;
  1230.     {$ENDC}
  1231. FUNCTION VDGetFieldPreference(ci: VideoDigitizerComponent; VAR fieldFlag: INTEGER): VideoDigitizerError;
  1232.     {$IFC NOT GENERATINGCFM}
  1233.     INLINE $2F3C, $0004, $0030, $7000, $A82A;
  1234.     {$ENDC}
  1235. FUNCTION VDPreflightDestination(ci: VideoDigitizerComponent; VAR digitizerRect: Rect; VAR dest: PixMapPtr; VAR destRect: Rect; VAR m: MatrixRecord): VideoDigitizerError;
  1236.     {$IFC NOT GENERATINGCFM}
  1237.     INLINE $2F3C, $0010, $0032, $7000, $A82A;
  1238.     {$ENDC}
  1239. FUNCTION VDPreflightGlobalRect(ci: VideoDigitizerComponent; theWindow: GrafPtr; VAR globalRect: Rect): VideoDigitizerError;
  1240.     {$IFC NOT GENERATINGCFM}
  1241.     INLINE $2F3C, $0008, $0033, $7000, $A82A;
  1242.     {$ENDC}
  1243. FUNCTION VDSetPlayThruGlobalRect(ci: VideoDigitizerComponent; theWindow: GrafPtr; VAR globalRect: Rect): VideoDigitizerError;
  1244.     {$IFC NOT GENERATINGCFM}
  1245.     INLINE $2F3C, $0008, $0034, $7000, $A82A;
  1246.     {$ENDC}
  1247. FUNCTION VDSetInputGammaRecord(ci: VideoDigitizerComponent; inputGammaPtr: VDGamRecPtr): VideoDigitizerError;
  1248.     {$IFC NOT GENERATINGCFM}
  1249.     INLINE $2F3C, $0004, $0035, $7000, $A82A;
  1250.     {$ENDC}
  1251. FUNCTION VDGetInputGammaRecord(ci: VideoDigitizerComponent; VAR inputGammaPtr: VDGamRecPtr): VideoDigitizerError;
  1252.     {$IFC NOT GENERATINGCFM}
  1253.     INLINE $2F3C, $0004, $0036, $7000, $A82A;
  1254.     {$ENDC}
  1255. FUNCTION VDSetBlackLevelValue(ci: VideoDigitizerComponent; VAR blackLevel: INTEGER): VideoDigitizerError;
  1256.     {$IFC NOT GENERATINGCFM}
  1257.     INLINE $2F3C, $0004, $0037, $7000, $A82A;
  1258.     {$ENDC}
  1259. FUNCTION VDGetBlackLevelValue(ci: VideoDigitizerComponent; VAR blackLevel: INTEGER): VideoDigitizerError;
  1260.     {$IFC NOT GENERATINGCFM}
  1261.     INLINE $2F3C, $0004, $0038, $7000, $A82A;
  1262.     {$ENDC}
  1263. FUNCTION VDSetWhiteLevelValue(ci: VideoDigitizerComponent; VAR whiteLevel: INTEGER): VideoDigitizerError;
  1264.     {$IFC NOT GENERATINGCFM}
  1265.     INLINE $2F3C, $0004, $0039, $7000, $A82A;
  1266.     {$ENDC}
  1267. FUNCTION VDGetWhiteLevelValue(ci: VideoDigitizerComponent; VAR whiteLevel: INTEGER): VideoDigitizerError;
  1268.     {$IFC NOT GENERATINGCFM}
  1269.     INLINE $2F3C, $0004, $003A, $7000, $A82A;
  1270.     {$ENDC}
  1271. FUNCTION VDGetVideoDefaults(ci: VideoDigitizerComponent; VAR blackLevel: INTEGER; VAR whiteLevel: INTEGER; VAR brightness: INTEGER; VAR hue: INTEGER; VAR saturation: INTEGER; VAR contrast: INTEGER; VAR sharpness: INTEGER): VideoDigitizerError;
  1272.     {$IFC NOT GENERATINGCFM}
  1273.     INLINE $2F3C, $001C, $003B, $7000, $A82A;
  1274.     {$ENDC}
  1275. FUNCTION VDGetNumberOfInputs(ci: VideoDigitizerComponent; VAR inputs: INTEGER): VideoDigitizerError;
  1276.     {$IFC NOT GENERATINGCFM}
  1277.     INLINE $2F3C, $0004, $003C, $7000, $A82A;
  1278.     {$ENDC}
  1279. FUNCTION VDGetInputFormat(ci: VideoDigitizerComponent; input: INTEGER; VAR format: INTEGER): VideoDigitizerError;
  1280.     {$IFC NOT GENERATINGCFM}
  1281.     INLINE $2F3C, $0006, $003D, $7000, $A82A;
  1282.     {$ENDC}
  1283. FUNCTION VDSetInput(ci: VideoDigitizerComponent; input: INTEGER): VideoDigitizerError;
  1284.     {$IFC NOT GENERATINGCFM}
  1285.     INLINE $2F3C, $0002, $003E, $7000, $A82A;
  1286.     {$ENDC}
  1287. FUNCTION VDGetInput(ci: VideoDigitizerComponent; VAR input: INTEGER): VideoDigitizerError;
  1288.     {$IFC NOT GENERATINGCFM}
  1289.     INLINE $2F3C, $0004, $003F, $7000, $A82A;
  1290.     {$ENDC}
  1291. FUNCTION VDSetInputStandard(ci: VideoDigitizerComponent; inputStandard: INTEGER): VideoDigitizerError;
  1292.     {$IFC NOT GENERATINGCFM}
  1293.     INLINE $2F3C, $0002, $0040, $7000, $A82A;
  1294.     {$ENDC}
  1295. FUNCTION VDSetupBuffers(ci: VideoDigitizerComponent; bufferList: VdigBufferRecListHandle): VideoDigitizerError;
  1296.     {$IFC NOT GENERATINGCFM}
  1297.     INLINE $2F3C, $0004, $0041, $7000, $A82A;
  1298.     {$ENDC}
  1299. FUNCTION VDGrabOneFrameAsync(ci: VideoDigitizerComponent; buffer: INTEGER): VideoDigitizerError;
  1300.     {$IFC NOT GENERATINGCFM}
  1301.     INLINE $2F3C, $0002, $0042, $7000, $A82A;
  1302.     {$ENDC}
  1303. FUNCTION VDDone(ci: VideoDigitizerComponent; buffer: INTEGER): VideoDigitizerError;
  1304.     {$IFC NOT GENERATINGCFM}
  1305.     INLINE $2F3C, $0002, $0043, $7000, $A82A;
  1306.     {$ENDC}
  1307. FUNCTION VDSetCompression(ci: VideoDigitizerComponent; compressType: OSType; depth: INTEGER; VAR bounds: Rect; spatialQuality: CodecQ; temporalQuality: CodecQ; keyFrameRate: LONGINT): VideoDigitizerError;
  1308.     {$IFC NOT GENERATINGCFM}
  1309.     INLINE $2F3C, $0016, $0044, $7000, $A82A;
  1310.     {$ENDC}
  1311. FUNCTION VDCompressOneFrameAsync(ci: VideoDigitizerComponent): VideoDigitizerError;
  1312.     {$IFC NOT GENERATINGCFM}
  1313.     INLINE $2F3C, $0000, $0045, $7000, $A82A;
  1314.     {$ENDC}
  1315. FUNCTION VDCompressDone(ci: VideoDigitizerComponent; VAR done: BOOLEAN; VAR theData: Ptr; VAR dataSize: LONGINT; VAR similarity: UInt8; VAR t: TimeRecord): VideoDigitizerError;
  1316.     {$IFC NOT GENERATINGCFM}
  1317.     INLINE $2F3C, $0014, $0046, $7000, $A82A;
  1318.     {$ENDC}
  1319. FUNCTION VDReleaseCompressBuffer(ci: VideoDigitizerComponent; bufferAddr: Ptr): VideoDigitizerError;
  1320.     {$IFC NOT GENERATINGCFM}
  1321.     INLINE $2F3C, $0004, $0047, $7000, $A82A;
  1322.     {$ENDC}
  1323. FUNCTION VDGetImageDescription(ci: VideoDigitizerComponent; desc: ImageDescriptionHandle): VideoDigitizerError;
  1324.     {$IFC NOT GENERATINGCFM}
  1325.     INLINE $2F3C, $0004, $0048, $7000, $A82A;
  1326.     {$ENDC}
  1327. FUNCTION VDResetCompressSequence(ci: VideoDigitizerComponent): VideoDigitizerError;
  1328.     {$IFC NOT GENERATINGCFM}
  1329.     INLINE $2F3C, $0000, $0049, $7000, $A82A;
  1330.     {$ENDC}
  1331. FUNCTION VDSetCompressionOnOff(ci: VideoDigitizerComponent; state: BOOLEAN): VideoDigitizerError;
  1332.     {$IFC NOT GENERATINGCFM}
  1333.     INLINE $2F3C, $0002, $004A, $7000, $A82A;
  1334.     {$ENDC}
  1335. FUNCTION VDGetCompressionTypes(ci: VideoDigitizerComponent; h: VDCompressionListHandle): VideoDigitizerError;
  1336.     {$IFC NOT GENERATINGCFM}
  1337.     INLINE $2F3C, $0004, $004B, $7000, $A82A;
  1338.     {$ENDC}
  1339. FUNCTION VDSetTimeBase(ci: VideoDigitizerComponent; t: TimeBase): VideoDigitizerError;
  1340.     {$IFC NOT GENERATINGCFM}
  1341.     INLINE $2F3C, $0004, $004C, $7000, $A82A;
  1342.     {$ENDC}
  1343. FUNCTION VDSetFrameRate(ci: VideoDigitizerComponent; framesPerSecond: Fixed): VideoDigitizerError;
  1344.     {$IFC NOT GENERATINGCFM}
  1345.     INLINE $2F3C, $0004, $004D, $7000, $A82A;
  1346.     {$ENDC}
  1347. FUNCTION VDGetDataRate(ci: VideoDigitizerComponent; VAR milliSecPerFrame: LONGINT; VAR framesPerSecond: Fixed; VAR bytesPerSecond: LONGINT): VideoDigitizerError;
  1348.     {$IFC NOT GENERATINGCFM}
  1349.     INLINE $2F3C, $000C, $004E, $7000, $A82A;
  1350.     {$ENDC}
  1351. FUNCTION VDGetSoundInputDriver(ci: VideoDigitizerComponent; VAR soundDriverName: Str255): VideoDigitizerError;
  1352.     {$IFC NOT GENERATINGCFM}
  1353.     INLINE $2F3C, $0004, $004F, $7000, $A82A;
  1354.     {$ENDC}
  1355. FUNCTION VDGetDMADepths(ci: VideoDigitizerComponent; VAR depthArray: LONGINT; VAR preferredDepth: LONGINT): VideoDigitizerError;
  1356.     {$IFC NOT GENERATINGCFM}
  1357.     INLINE $2F3C, $0008, $0050, $7000, $A82A;
  1358.     {$ENDC}
  1359. FUNCTION VDGetPreferredTimeScale(ci: VideoDigitizerComponent; VAR preferred: TimeScale): VideoDigitizerError;
  1360.     {$IFC NOT GENERATINGCFM}
  1361.     INLINE $2F3C, $0004, $0051, $7000, $A82A;
  1362.     {$ENDC}
  1363. FUNCTION VDReleaseAsyncBuffers(ci: VideoDigitizerComponent): VideoDigitizerError;
  1364.     {$IFC NOT GENERATINGCFM}
  1365.     INLINE $2F3C, $0000, $0052, $7000, $A82A;
  1366.     {$ENDC}
  1367. {  83 is reserved for compatibility reasons  }
  1368. FUNCTION VDSetDataRate(ci: VideoDigitizerComponent; bytesPerSecond: LONGINT): VideoDigitizerError;
  1369.     {$IFC NOT GENERATINGCFM}
  1370.     INLINE $2F3C, $0004, $0054, $7000, $A82A;
  1371.     {$ENDC}
  1372. FUNCTION VDGetTimeCode(ci: VideoDigitizerComponent; VAR atTime: TimeRecord; timeCodeFormat: UNIV Ptr; timeCodeTime: UNIV Ptr): VideoDigitizerError;
  1373.     {$IFC NOT GENERATINGCFM}
  1374.     INLINE $2F3C, $000C, $0055, $7000, $A82A;
  1375.     {$ENDC}
  1376. FUNCTION VDUseSafeBuffers(ci: VideoDigitizerComponent; useSafeBuffers: BOOLEAN): VideoDigitizerError;
  1377.     {$IFC NOT GENERATINGCFM}
  1378.     INLINE $2F3C, $0002, $0056, $7000, $A82A;
  1379.     {$ENDC}
  1380. FUNCTION VDGetSoundInputSource(ci: VideoDigitizerComponent; videoInput: LONGINT; VAR soundInput: LONGINT): VideoDigitizerError;
  1381.     {$IFC NOT GENERATINGCFM}
  1382.     INLINE $2F3C, $0008, $0057, $7000, $A82A;
  1383.     {$ENDC}
  1384. FUNCTION VDGetCompressionTime(ci: VideoDigitizerComponent; compressionType: OSType; depth: INTEGER; VAR srcRect: Rect; VAR spatialQuality: CodecQ; VAR temporalQuality: CodecQ; VAR compressTime: LONGINT): VideoDigitizerError;
  1385.     {$IFC NOT GENERATINGCFM}
  1386.     INLINE $2F3C, $0016, $0058, $7000, $A82A;
  1387.     {$ENDC}
  1388. FUNCTION VDSetPreferredPacketSize(ci: VideoDigitizerComponent; preferredPacketSizeInBytes: LONGINT): VideoDigitizerError;
  1389.     {$IFC NOT GENERATINGCFM}
  1390.     INLINE $2F3C, $0004, $0059, $7000, $A82A;
  1391.     {$ENDC}
  1392. {
  1393.     General Sequence Grab stuff
  1394. }
  1395.  
  1396. TYPE
  1397.     SeqGrabComponent                    = ComponentInstance;
  1398.     SGChannel                            = ComponentInstance;
  1399.  
  1400. CONST
  1401.     SeqGrabComponentType        = 'barg';
  1402.     SeqGrabChannelType            = 'sgch';
  1403.     SeqGrabPanelType            = 'sgpn';
  1404.     SeqGrabCompressionPanelType    = 'cmpr';
  1405.     SeqGrabSourcePanelType        = 'sour';
  1406.  
  1407.     seqGrabToDisk                = 1;
  1408.     seqGrabToMemory                = 2;
  1409.     seqGrabDontUseTempMemory    = 4;
  1410.     seqGrabAppendToFile            = 8;
  1411.     seqGrabDontAddMovieResource    = 16;
  1412.     seqGrabDontMakeMovie        = 32;
  1413.     seqGrabPreExtendFile        = 64;
  1414.     seqGrabDataProcIsInterruptSafe = 128;
  1415.     seqGrabDataProcDoesOverlappingReads = 256;
  1416.  
  1417.  
  1418. TYPE
  1419.     SeqGrabDataOutputEnum                = LONGINT;
  1420.  
  1421. CONST
  1422.     seqGrabRecord                = 1;
  1423.     seqGrabPreview                = 2;
  1424.     seqGrabPlayDuringRecord        = 4;
  1425.  
  1426.  
  1427. TYPE
  1428.     SeqGrabUsageEnum                    = LONGINT;
  1429.  
  1430. CONST
  1431.     seqGrabHasBounds            = 1;
  1432.     seqGrabHasVolume            = 2;
  1433.     seqGrabHasDiscreteSamples    = 4;
  1434.  
  1435.  
  1436. TYPE
  1437.     SeqGrabChannelInfoEnum                = LONGINT;
  1438.     SeqGrabFrameInfoPtr = ^SeqGrabFrameInfo;
  1439.     SeqGrabFrameInfo = RECORD
  1440.         frameOffset:            LONGINT;
  1441.         frameTime:                LONGINT;
  1442.         frameSize:                LONGINT;
  1443.         frameChannel:            SGChannel;
  1444.         frameRefCon:            LONGINT;
  1445.     END;
  1446.  
  1447.  
  1448. CONST
  1449.     grabPictOffScreen            = 1;
  1450.     grabPictIgnoreClip            = 2;
  1451.     grabPictCurrentImage        = 4;
  1452.  
  1453.     sgFlagControlledGrab        = $01;
  1454.  
  1455.  
  1456. TYPE
  1457.     SGDataProcPtr = ProcPtr;  { FUNCTION SGData(c: SGChannel; p: Ptr; len: LONGINT; VAR offset: LONGINT; chRefCon: LONGINT; time: TimeValue; writeType: INTEGER; refCon: LONGINT): OSErr; }
  1458.  
  1459.     SGDataUPP = UniversalProcPtr;
  1460.     SGDeviceNamePtr = ^SGDeviceName;
  1461.     SGDeviceName = RECORD
  1462.         name:                    Str63;
  1463.         icon:                    Handle;
  1464.         flags:                    LONGINT;
  1465.         refCon:                    LONGINT;
  1466.         reserved:                LONGINT;                                {  zero }
  1467.     END;
  1468.  
  1469.  
  1470. CONST
  1471.     sgDeviceNameFlagDeviceUnavailable = $01;
  1472.  
  1473.  
  1474. TYPE
  1475.     SGDeviceListRecordPtr = ^SGDeviceListRecord;
  1476.     SGDeviceListRecord = RECORD
  1477.         count:                    INTEGER;
  1478.         selectedIndex:            INTEGER;
  1479.         reserved:                LONGINT;                                {  zero }
  1480.         entry:                    ARRAY [0..0] OF SGDeviceName;
  1481.     END;
  1482.  
  1483.     SGDeviceListPtr                        = ^SGDeviceListRecord;
  1484.     SGDeviceList                        = ^SGDeviceListPtr;
  1485.  
  1486. CONST
  1487.     sgDeviceListWithIcons        = $01;
  1488.     sgDeviceListDontCheckAvailability = $02;
  1489.  
  1490.     seqGrabWriteAppend            = 0;
  1491.     seqGrabWriteReserve            = 1;
  1492.     seqGrabWriteFill            = 2;
  1493.  
  1494.     seqGrabUnpause                = 0;
  1495.     seqGrabPause                = 1;
  1496.     seqGrabPauseForMenu            = 3;
  1497.  
  1498.     channelFlagDontOpenResFile    = 2;
  1499.     channelFlagHasDependency    = 4;
  1500.  
  1501.  
  1502. TYPE
  1503.     SGModalFilterProcPtr = ProcPtr;  { FUNCTION SGModalFilter(theDialog: DialogPtr; VAR theEvent: EventRecord; VAR itemHit: INTEGER; refCon: LONGINT): BOOLEAN; }
  1504.  
  1505.     SGModalFilterUPP = UniversalProcPtr;
  1506.  
  1507. CONST
  1508.     sgPanelFlagForPanel            = 1;
  1509.  
  1510.     seqGrabSettingsPreviewOnly    = 1;
  1511.  
  1512.  
  1513. TYPE
  1514.     SGOutputRecordPtr = ^SGOutputRecord;
  1515.     SGOutputRecord = RECORD
  1516.         data:                    ARRAY [0..0] OF LONGINT;
  1517.     END;
  1518.  
  1519.     SGOutput                            = ^SGOutputRecord;
  1520.  
  1521. CONST
  1522.     channelPlayNormal            = 0;
  1523.     channelPlayFast                = 1;
  1524.     channelPlayHighQuality        = 2;
  1525.     channelPlayAllData            = 4;
  1526.  
  1527. FUNCTION SGInitialize(s: SeqGrabComponent): ComponentResult;
  1528.     {$IFC NOT GENERATINGCFM}
  1529.     INLINE $2F3C, $0000, $0001, $7000, $A82A;
  1530.     {$ENDC}
  1531. FUNCTION SGSetDataOutput(s: SeqGrabComponent; {CONST}VAR movieFile: FSSpec; whereFlags: LONGINT): ComponentResult;
  1532.     {$IFC NOT GENERATINGCFM}
  1533.     INLINE $2F3C, $0008, $0002, $7000, $A82A;
  1534.     {$ENDC}
  1535. FUNCTION SGGetDataOutput(s: SeqGrabComponent; VAR movieFile: FSSpec; VAR whereFlags: LONGINT): ComponentResult;
  1536.     {$IFC NOT GENERATINGCFM}
  1537.     INLINE $2F3C, $0008, $0003, $7000, $A82A;
  1538.     {$ENDC}
  1539. FUNCTION SGSetGWorld(s: SeqGrabComponent; gp: CGrafPtr; gd: GDHandle): ComponentResult;
  1540.     {$IFC NOT GENERATINGCFM}
  1541.     INLINE $2F3C, $0008, $0004, $7000, $A82A;
  1542.     {$ENDC}
  1543. FUNCTION SGGetGWorld(s: SeqGrabComponent; VAR gp: CGrafPtr; VAR gd: GDHandle): ComponentResult;
  1544.     {$IFC NOT GENERATINGCFM}
  1545.     INLINE $2F3C, $0008, $0005, $7000, $A82A;
  1546.     {$ENDC}
  1547. FUNCTION SGNewChannel(s: SeqGrabComponent; channelType: OSType; VAR ref: SGChannel): ComponentResult;
  1548.     {$IFC NOT GENERATINGCFM}
  1549.     INLINE $2F3C, $0008, $0006, $7000, $A82A;
  1550.     {$ENDC}
  1551. FUNCTION SGDisposeChannel(s: SeqGrabComponent; c: SGChannel): ComponentResult;
  1552.     {$IFC NOT GENERATINGCFM}
  1553.     INLINE $2F3C, $0004, $0007, $7000, $A82A;
  1554.     {$ENDC}
  1555. FUNCTION SGStartPreview(s: SeqGrabComponent): ComponentResult;
  1556.     {$IFC NOT GENERATINGCFM}
  1557.     INLINE $2F3C, $0000, $0010, $7000, $A82A;
  1558.     {$ENDC}
  1559. FUNCTION SGStartRecord(s: SeqGrabComponent): ComponentResult;
  1560.     {$IFC NOT GENERATINGCFM}
  1561.     INLINE $2F3C, $0000, $0011, $7000, $A82A;
  1562.     {$ENDC}
  1563. FUNCTION SGIdle(s: SeqGrabComponent): ComponentResult;
  1564.     {$IFC NOT GENERATINGCFM}
  1565.     INLINE $2F3C, $0000, $0012, $7000, $A82A;
  1566.     {$ENDC}
  1567. FUNCTION SGStop(s: SeqGrabComponent): ComponentResult;
  1568.     {$IFC NOT GENERATINGCFM}
  1569.     INLINE $2F3C, $0000, $0013, $7000, $A82A;
  1570.     {$ENDC}
  1571. FUNCTION SGPause(s: SeqGrabComponent; pause: ByteParameter): ComponentResult;
  1572.     {$IFC NOT GENERATINGCFM}
  1573.     INLINE $2F3C, $0002, $0014, $7000, $A82A;
  1574.     {$ENDC}
  1575. FUNCTION SGPrepare(s: SeqGrabComponent; prepareForPreview: BOOLEAN; prepareForRecord: BOOLEAN): ComponentResult;
  1576.     {$IFC NOT GENERATINGCFM}
  1577.     INLINE $2F3C, $0004, $0015, $7000, $A82A;
  1578.     {$ENDC}
  1579. FUNCTION SGRelease(s: SeqGrabComponent): ComponentResult;
  1580.     {$IFC NOT GENERATINGCFM}
  1581.     INLINE $2F3C, $0000, $0016, $7000, $A82A;
  1582.     {$ENDC}
  1583. FUNCTION SGGetMovie(s: SeqGrabComponent): Movie;
  1584.     {$IFC NOT GENERATINGCFM}
  1585.     INLINE $2F3C, $0000, $0017, $7000, $A82A;
  1586.     {$ENDC}
  1587. FUNCTION SGSetMaximumRecordTime(s: SeqGrabComponent; ticks: LONGINT): ComponentResult;
  1588.     {$IFC NOT GENERATINGCFM}
  1589.     INLINE $2F3C, $0004, $0018, $7000, $A82A;
  1590.     {$ENDC}
  1591. FUNCTION SGGetMaximumRecordTime(s: SeqGrabComponent; VAR ticks: LONGINT): ComponentResult;
  1592.     {$IFC NOT GENERATINGCFM}
  1593.     INLINE $2F3C, $0004, $0019, $7000, $A82A;
  1594.     {$ENDC}
  1595. FUNCTION SGGetStorageSpaceRemaining(s: SeqGrabComponent; VAR bytes: LONGINT): ComponentResult;
  1596.     {$IFC NOT GENERATINGCFM}
  1597.     INLINE $2F3C, $0004, $001A, $7000, $A82A;
  1598.     {$ENDC}
  1599. FUNCTION SGGetTimeRemaining(s: SeqGrabComponent; VAR ticksLeft: LONGINT): ComponentResult;
  1600.     {$IFC NOT GENERATINGCFM}
  1601.     INLINE $2F3C, $0004, $001B, $7000, $A82A;
  1602.     {$ENDC}
  1603. FUNCTION SGGrabPict(s: SeqGrabComponent; VAR p: PicHandle; {CONST}VAR bounds: Rect; offscreenDepth: INTEGER; grabPictFlags: LONGINT): ComponentResult;
  1604.     {$IFC NOT GENERATINGCFM}
  1605.     INLINE $2F3C, $000E, $001C, $7000, $A82A;
  1606.     {$ENDC}
  1607. FUNCTION SGGetLastMovieResID(s: SeqGrabComponent; VAR resID: INTEGER): ComponentResult;
  1608.     {$IFC NOT GENERATINGCFM}
  1609.     INLINE $2F3C, $0004, $001D, $7000, $A82A;
  1610.     {$ENDC}
  1611. FUNCTION SGSetFlags(s: SeqGrabComponent; sgFlags: LONGINT): ComponentResult;
  1612.     {$IFC NOT GENERATINGCFM}
  1613.     INLINE $2F3C, $0004, $001E, $7000, $A82A;
  1614.     {$ENDC}
  1615. FUNCTION SGGetFlags(s: SeqGrabComponent; VAR sgFlags: LONGINT): ComponentResult;
  1616.     {$IFC NOT GENERATINGCFM}
  1617.     INLINE $2F3C, $0004, $001F, $7000, $A82A;
  1618.     {$ENDC}
  1619. FUNCTION SGSetDataProc(s: SeqGrabComponent; proc: SGDataUPP; refCon: LONGINT): ComponentResult;
  1620.     {$IFC NOT GENERATINGCFM}
  1621.     INLINE $2F3C, $0008, $0020, $7000, $A82A;
  1622.     {$ENDC}
  1623. FUNCTION SGNewChannelFromComponent(s: SeqGrabComponent; VAR newChannel: SGChannel; sgChannelComponent: Component): ComponentResult;
  1624.     {$IFC NOT GENERATINGCFM}
  1625.     INLINE $2F3C, $0008, $0021, $7000, $A82A;
  1626.     {$ENDC}
  1627. FUNCTION SGDisposeDeviceList(s: SeqGrabComponent; list: SGDeviceList): ComponentResult;
  1628.     {$IFC NOT GENERATINGCFM}
  1629.     INLINE $2F3C, $0004, $0022, $7000, $A82A;
  1630.     {$ENDC}
  1631. FUNCTION SGAppendDeviceListToMenu(s: SeqGrabComponent; list: SGDeviceList; mh: MenuHandle): ComponentResult;
  1632.     {$IFC NOT GENERATINGCFM}
  1633.     INLINE $2F3C, $0008, $0023, $7000, $A82A;
  1634.     {$ENDC}
  1635. FUNCTION SGSetSettings(s: SeqGrabComponent; ud: UserData; flags: LONGINT): ComponentResult;
  1636.     {$IFC NOT GENERATINGCFM}
  1637.     INLINE $2F3C, $0008, $0024, $7000, $A82A;
  1638.     {$ENDC}
  1639. FUNCTION SGGetSettings(s: SeqGrabComponent; VAR ud: UserData; flags: LONGINT): ComponentResult;
  1640.     {$IFC NOT GENERATINGCFM}
  1641.     INLINE $2F3C, $0008, $0025, $7000, $A82A;
  1642.     {$ENDC}
  1643. FUNCTION SGGetIndChannel(s: SeqGrabComponent; index: INTEGER; VAR ref: SGChannel; VAR chanType: OSType): ComponentResult;
  1644.     {$IFC NOT GENERATINGCFM}
  1645.     INLINE $2F3C, $000A, $0026, $7000, $A82A;
  1646.     {$ENDC}
  1647. FUNCTION SGUpdate(s: SeqGrabComponent; updateRgn: RgnHandle): ComponentResult;
  1648.     {$IFC NOT GENERATINGCFM}
  1649.     INLINE $2F3C, $0004, $0027, $7000, $A82A;
  1650.     {$ENDC}
  1651. FUNCTION SGGetPause(s: SeqGrabComponent; VAR paused: Byte): ComponentResult;
  1652.     {$IFC NOT GENERATINGCFM}
  1653.     INLINE $2F3C, $0004, $0028, $7000, $A82A;
  1654.     {$ENDC}
  1655.  
  1656. TYPE
  1657.     ConstComponentListPtr                = ^Component;
  1658. FUNCTION SGSettingsDialog(s: SeqGrabComponent; c: SGChannel; numPanels: INTEGER; panelList: ConstComponentListPtr; flags: LONGINT; proc: SGModalFilterUPP; procRefNum: LONGINT): ComponentResult;
  1659.     {$IFC NOT GENERATINGCFM}
  1660.     INLINE $2F3C, $0016, $0029, $7000, $A82A;
  1661.     {$ENDC}
  1662. FUNCTION SGGetAlignmentProc(s: SeqGrabComponent; alignmentProc: ICMAlignmentProcRecordPtr): ComponentResult;
  1663.     {$IFC NOT GENERATINGCFM}
  1664.     INLINE $2F3C, $0004, $002A, $7000, $A82A;
  1665.     {$ENDC}
  1666. FUNCTION SGSetChannelSettings(s: SeqGrabComponent; c: SGChannel; ud: UserData; flags: LONGINT): ComponentResult;
  1667.     {$IFC NOT GENERATINGCFM}
  1668.     INLINE $2F3C, $000C, $002B, $7000, $A82A;
  1669.     {$ENDC}
  1670. FUNCTION SGGetChannelSettings(s: SeqGrabComponent; c: SGChannel; VAR ud: UserData; flags: LONGINT): ComponentResult;
  1671.     {$IFC NOT GENERATINGCFM}
  1672.     INLINE $2F3C, $000C, $002C, $7000, $A82A;
  1673.     {$ENDC}
  1674. FUNCTION SGGetMode(s: SeqGrabComponent; VAR previewMode: BOOLEAN; VAR recordMode: BOOLEAN): ComponentResult;
  1675.     {$IFC NOT GENERATINGCFM}
  1676.     INLINE $2F3C, $0008, $002D, $7000, $A82A;
  1677.     {$ENDC}
  1678. FUNCTION SGSetDataRef(s: SeqGrabComponent; dataRef: Handle; dataRefType: OSType; whereFlags: LONGINT): ComponentResult;
  1679.     {$IFC NOT GENERATINGCFM}
  1680.     INLINE $2F3C, $000C, $002E, $7000, $A82A;
  1681.     {$ENDC}
  1682. FUNCTION SGGetDataRef(s: SeqGrabComponent; VAR dataRef: Handle; VAR dataRefType: OSType; VAR whereFlags: LONGINT): ComponentResult;
  1683.     {$IFC NOT GENERATINGCFM}
  1684.     INLINE $2F3C, $000C, $002F, $7000, $A82A;
  1685.     {$ENDC}
  1686. FUNCTION SGNewOutput(s: SeqGrabComponent; dataRef: Handle; dataRefType: OSType; whereFlags: LONGINT; VAR sgOut: SGOutput): ComponentResult;
  1687.     {$IFC NOT GENERATINGCFM}
  1688.     INLINE $2F3C, $0010, $0030, $7000, $A82A;
  1689.     {$ENDC}
  1690. FUNCTION SGDisposeOutput(s: SeqGrabComponent; sgOut: SGOutput): ComponentResult;
  1691.     {$IFC NOT GENERATINGCFM}
  1692.     INLINE $2F3C, $0004, $0031, $7000, $A82A;
  1693.     {$ENDC}
  1694. FUNCTION SGSetOutputFlags(s: SeqGrabComponent; sgOut: SGOutput; whereFlags: LONGINT): ComponentResult;
  1695.     {$IFC NOT GENERATINGCFM}
  1696.     INLINE $2F3C, $0008, $0032, $7000, $A82A;
  1697.     {$ENDC}
  1698. FUNCTION SGSetChannelOutput(s: SeqGrabComponent; c: SGChannel; sgOut: SGOutput): ComponentResult;
  1699.     {$IFC NOT GENERATINGCFM}
  1700.     INLINE $2F3C, $0008, $0033, $7000, $A82A;
  1701.     {$ENDC}
  1702. FUNCTION SGGetDataOutputStorageSpaceRemaining(s: SeqGrabComponent; sgOut: SGOutput; VAR space: LONGINT): ComponentResult;
  1703.     {$IFC NOT GENERATINGCFM}
  1704.     INLINE $2F3C, $0008, $0034, $7000, $A82A;
  1705.     {$ENDC}
  1706. FUNCTION SGHandleUpdateEvent(s: SeqGrabComponent; VAR event: EventRecord; VAR handled: BOOLEAN): ComponentResult;
  1707.     {$IFC NOT GENERATINGCFM}
  1708.     INLINE $2F3C, $0008, $0035, $7000, $A82A;
  1709.     {$ENDC}
  1710. {
  1711.     calls from Channel to seqGrab
  1712. }
  1713. FUNCTION SGWriteMovieData(s: SeqGrabComponent; c: SGChannel; p: Ptr; len: LONGINT; VAR offset: LONGINT): ComponentResult;
  1714.     {$IFC NOT GENERATINGCFM}
  1715.     INLINE $2F3C, $0010, $0100, $7000, $A82A;
  1716.     {$ENDC}
  1717. FUNCTION SGAddFrameReference(s: SeqGrabComponent; frameInfo: SeqGrabFrameInfoPtr): ComponentResult;
  1718.     {$IFC NOT GENERATINGCFM}
  1719.     INLINE $2F3C, $0004, $0101, $7000, $A82A;
  1720.     {$ENDC}
  1721. FUNCTION SGGetNextFrameReference(s: SeqGrabComponent; frameInfo: SeqGrabFrameInfoPtr; VAR frameDuration: TimeValue; VAR frameNumber: LONGINT): ComponentResult;
  1722.     {$IFC NOT GENERATINGCFM}
  1723.     INLINE $2F3C, $000C, $0102, $7000, $A82A;
  1724.     {$ENDC}
  1725. FUNCTION SGGetTimeBase(s: SeqGrabComponent; VAR tb: TimeBase): ComponentResult;
  1726.     {$IFC NOT GENERATINGCFM}
  1727.     INLINE $2F3C, $0004, $0103, $7000, $A82A;
  1728.     {$ENDC}
  1729. FUNCTION SGSortDeviceList(s: SeqGrabComponent; list: SGDeviceList): ComponentResult;
  1730.     {$IFC NOT GENERATINGCFM}
  1731.     INLINE $2F3C, $0004, $0104, $7000, $A82A;
  1732.     {$ENDC}
  1733. FUNCTION SGAddMovieData(s: SeqGrabComponent; c: SGChannel; p: Ptr; len: LONGINT; VAR offset: LONGINT; chRefCon: LONGINT; time: TimeValue; writeType: INTEGER): ComponentResult;
  1734.     {$IFC NOT GENERATINGCFM}
  1735.     INLINE $2F3C, $001A, $0105, $7000, $A82A;
  1736.     {$ENDC}
  1737. FUNCTION SGChangedSource(s: SeqGrabComponent; c: SGChannel): ComponentResult;
  1738.     {$IFC NOT GENERATINGCFM}
  1739.     INLINE $2F3C, $0004, $0106, $7000, $A82A;
  1740.     {$ENDC}
  1741. { ** Sequence Grab CHANNEL Component Stuff ** }
  1742. FUNCTION SGSetChannelUsage(c: SGChannel; usage: LONGINT): ComponentResult;
  1743.     {$IFC NOT GENERATINGCFM}
  1744.     INLINE $2F3C, $0004, $0080, $7000, $A82A;
  1745.     {$ENDC}
  1746. FUNCTION SGGetChannelUsage(c: SGChannel; VAR usage: LONGINT): ComponentResult;
  1747.     {$IFC NOT GENERATINGCFM}
  1748.     INLINE $2F3C, $0004, $0081, $7000, $A82A;
  1749.     {$ENDC}
  1750. FUNCTION SGSetChannelBounds(c: SGChannel; {CONST}VAR bounds: Rect): ComponentResult;
  1751.     {$IFC NOT GENERATINGCFM}
  1752.     INLINE $2F3C, $0004, $0082, $7000, $A82A;
  1753.     {$ENDC}
  1754. FUNCTION SGGetChannelBounds(c: SGChannel; VAR bounds: Rect): ComponentResult;
  1755.     {$IFC NOT GENERATINGCFM}
  1756.     INLINE $2F3C, $0004, $0083, $7000, $A82A;
  1757.     {$ENDC}
  1758. FUNCTION SGSetChannelVolume(c: SGChannel; volume: INTEGER): ComponentResult;
  1759.     {$IFC NOT GENERATINGCFM}
  1760.     INLINE $2F3C, $0002, $0084, $7000, $A82A;
  1761.     {$ENDC}
  1762. FUNCTION SGGetChannelVolume(c: SGChannel; VAR volume: INTEGER): ComponentResult;
  1763.     {$IFC NOT GENERATINGCFM}
  1764.     INLINE $2F3C, $0004, $0085, $7000, $A82A;
  1765.     {$ENDC}
  1766. FUNCTION SGGetChannelInfo(c: SGChannel; VAR channelInfo: LONGINT): ComponentResult;
  1767.     {$IFC NOT GENERATINGCFM}
  1768.     INLINE $2F3C, $0004, $0086, $7000, $A82A;
  1769.     {$ENDC}
  1770. FUNCTION SGSetChannelPlayFlags(c: SGChannel; playFlags: LONGINT): ComponentResult;
  1771.     {$IFC NOT GENERATINGCFM}
  1772.     INLINE $2F3C, $0004, $0087, $7000, $A82A;
  1773.     {$ENDC}
  1774. FUNCTION SGGetChannelPlayFlags(c: SGChannel; VAR playFlags: LONGINT): ComponentResult;
  1775.     {$IFC NOT GENERATINGCFM}
  1776.     INLINE $2F3C, $0004, $0088, $7000, $A82A;
  1777.     {$ENDC}
  1778. FUNCTION SGSetChannelMaxFrames(c: SGChannel; frameCount: LONGINT): ComponentResult;
  1779.     {$IFC NOT GENERATINGCFM}
  1780.     INLINE $2F3C, $0004, $0089, $7000, $A82A;
  1781.     {$ENDC}
  1782. FUNCTION SGGetChannelMaxFrames(c: SGChannel; VAR frameCount: LONGINT): ComponentResult;
  1783.     {$IFC NOT GENERATINGCFM}
  1784.     INLINE $2F3C, $0004, $008A, $7000, $A82A;
  1785.     {$ENDC}
  1786. FUNCTION SGSetChannelRefCon(c: SGChannel; refCon: LONGINT): ComponentResult;
  1787.     {$IFC NOT GENERATINGCFM}
  1788.     INLINE $2F3C, $0004, $008B, $7000, $A82A;
  1789.     {$ENDC}
  1790. FUNCTION SGSetChannelClip(c: SGChannel; theClip: RgnHandle): ComponentResult;
  1791.     {$IFC NOT GENERATINGCFM}
  1792.     INLINE $2F3C, $0004, $008C, $7000, $A82A;
  1793.     {$ENDC}
  1794. FUNCTION SGGetChannelClip(c: SGChannel; VAR theClip: RgnHandle): ComponentResult;
  1795.     {$IFC NOT GENERATINGCFM}
  1796.     INLINE $2F3C, $0004, $008D, $7000, $A82A;
  1797.     {$ENDC}
  1798. FUNCTION SGGetChannelSampleDescription(c: SGChannel; sampleDesc: Handle): ComponentResult;
  1799.     {$IFC NOT GENERATINGCFM}
  1800.     INLINE $2F3C, $0004, $008E, $7000, $A82A;
  1801.     {$ENDC}
  1802. FUNCTION SGGetChannelDeviceList(c: SGChannel; selectionFlags: LONGINT; VAR list: SGDeviceList): ComponentResult;
  1803.     {$IFC NOT GENERATINGCFM}
  1804.     INLINE $2F3C, $0008, $008F, $7000, $A82A;
  1805.     {$ENDC}
  1806. FUNCTION SGSetChannelDevice(c: SGChannel; name: StringPtr): ComponentResult;
  1807.     {$IFC NOT GENERATINGCFM}
  1808.     INLINE $2F3C, $0004, $0090, $7000, $A82A;
  1809.     {$ENDC}
  1810. FUNCTION SGSetChannelMatrix(c: SGChannel; {CONST}VAR m: MatrixRecord): ComponentResult;
  1811.     {$IFC NOT GENERATINGCFM}
  1812.     INLINE $2F3C, $0004, $0091, $7000, $A82A;
  1813.     {$ENDC}
  1814. FUNCTION SGGetChannelMatrix(c: SGChannel; VAR m: MatrixRecord): ComponentResult;
  1815.     {$IFC NOT GENERATINGCFM}
  1816.     INLINE $2F3C, $0004, $0092, $7000, $A82A;
  1817.     {$ENDC}
  1818. FUNCTION SGGetChannelTimeScale(c: SGChannel; VAR scale: TimeScale): ComponentResult;
  1819.     {$IFC NOT GENERATINGCFM}
  1820.     INLINE $2F3C, $0004, $0093, $7000, $A82A;
  1821.     {$ENDC}
  1822. FUNCTION SGChannelPutPicture(c: SGChannel): ComponentResult;
  1823.     {$IFC NOT GENERATINGCFM}
  1824.     INLINE $2F3C, $0000, $0094, $7000, $A82A;
  1825.     {$ENDC}
  1826. FUNCTION SGChannelSetRequestedDataRate(c: SGChannel; bytesPerSecond: LONGINT): ComponentResult;
  1827.     {$IFC NOT GENERATINGCFM}
  1828.     INLINE $2F3C, $0004, $0095, $7000, $A82A;
  1829.     {$ENDC}
  1830. FUNCTION SGChannelGetRequestedDataRate(c: SGChannel; VAR bytesPerSecond: LONGINT): ComponentResult;
  1831.     {$IFC NOT GENERATINGCFM}
  1832.     INLINE $2F3C, $0004, $0096, $7000, $A82A;
  1833.     {$ENDC}
  1834. FUNCTION SGChannelSetDataSourceName(c: SGChannel; name: Str255; scriptTag: ScriptCode): ComponentResult;
  1835.     {$IFC NOT GENERATINGCFM}
  1836.     INLINE $2F3C, $0006, $0097, $7000, $A82A;
  1837.     {$ENDC}
  1838. FUNCTION SGChannelGetDataSourceName(c: SGChannel; VAR name: Str255; VAR scriptTag: ScriptCode): ComponentResult;
  1839.     {$IFC NOT GENERATINGCFM}
  1840.     INLINE $2F3C, $0008, $0098, $7000, $A82A;
  1841.     {$ENDC}
  1842. {
  1843.     calls from seqGrab to Channel
  1844. }
  1845. FUNCTION SGInitChannel(c: SGChannel; owner: SeqGrabComponent): ComponentResult;
  1846.     {$IFC NOT GENERATINGCFM}
  1847.     INLINE $2F3C, $0004, $0180, $7000, $A82A;
  1848.     {$ENDC}
  1849. FUNCTION SGWriteSamples(c: SGChannel; m: Movie; theFile: AliasHandle): ComponentResult;
  1850.     {$IFC NOT GENERATINGCFM}
  1851.     INLINE $2F3C, $0008, $0181, $7000, $A82A;
  1852.     {$ENDC}
  1853. FUNCTION SGGetDataRate(c: SGChannel; VAR bytesPerSecond: LONGINT): ComponentResult;
  1854.     {$IFC NOT GENERATINGCFM}
  1855.     INLINE $2F3C, $0004, $0182, $7000, $A82A;
  1856.     {$ENDC}
  1857. FUNCTION SGAlignChannelRect(c: SGChannel; VAR r: Rect): ComponentResult;
  1858.     {$IFC NOT GENERATINGCFM}
  1859.     INLINE $2F3C, $0004, $0183, $7000, $A82A;
  1860.     {$ENDC}
  1861. {
  1862.     Dorky dialog panel calls
  1863. }
  1864. FUNCTION SGPanelGetDitl(s: SeqGrabComponent; VAR ditl: Handle): ComponentResult;
  1865.     {$IFC NOT GENERATINGCFM}
  1866.     INLINE $2F3C, $0004, $0200, $7000, $A82A;
  1867.     {$ENDC}
  1868. FUNCTION SGPanelGetTitle(s: SeqGrabComponent; VAR title: Str255): ComponentResult;
  1869.     {$IFC NOT GENERATINGCFM}
  1870.     INLINE $2F3C, $0004, $0201, $7000, $A82A;
  1871.     {$ENDC}
  1872. FUNCTION SGPanelCanRun(s: SeqGrabComponent; c: SGChannel): ComponentResult;
  1873.     {$IFC NOT GENERATINGCFM}
  1874.     INLINE $2F3C, $0004, $0202, $7000, $A82A;
  1875.     {$ENDC}
  1876. FUNCTION SGPanelInstall(s: SeqGrabComponent; c: SGChannel; d: DialogPtr; itemOffset: INTEGER): ComponentResult;
  1877.     {$IFC NOT GENERATINGCFM}
  1878.     INLINE $2F3C, $000A, $0203, $7000, $A82A;
  1879.     {$ENDC}
  1880. FUNCTION SGPanelEvent(s: SeqGrabComponent; c: SGChannel; d: DialogPtr; itemOffset: INTEGER; VAR theEvent: EventRecord; VAR itemHit: INTEGER; VAR handled: BOOLEAN): ComponentResult;
  1881.     {$IFC NOT GENERATINGCFM}
  1882.     INLINE $2F3C, $0016, $0204, $7000, $A82A;
  1883.     {$ENDC}
  1884. FUNCTION SGPanelItem(s: SeqGrabComponent; c: SGChannel; d: DialogPtr; itemOffset: INTEGER; itemNum: INTEGER): ComponentResult;
  1885.     {$IFC NOT GENERATINGCFM}
  1886.     INLINE $2F3C, $000C, $0205, $7000, $A82A;
  1887.     {$ENDC}
  1888. FUNCTION SGPanelRemove(s: SeqGrabComponent; c: SGChannel; d: DialogPtr; itemOffset: INTEGER): ComponentResult;
  1889.     {$IFC NOT GENERATINGCFM}
  1890.     INLINE $2F3C, $000A, $0206, $7000, $A82A;
  1891.     {$ENDC}
  1892. FUNCTION SGPanelSetGrabber(s: SeqGrabComponent; sg: SeqGrabComponent): ComponentResult;
  1893.     {$IFC NOT GENERATINGCFM}
  1894.     INLINE $2F3C, $0004, $0207, $7000, $A82A;
  1895.     {$ENDC}
  1896. FUNCTION SGPanelSetResFile(s: SeqGrabComponent; resRef: INTEGER): ComponentResult;
  1897.     {$IFC NOT GENERATINGCFM}
  1898.     INLINE $2F3C, $0002, $0208, $7000, $A82A;
  1899.     {$ENDC}
  1900. FUNCTION SGPanelGetSettings(s: SeqGrabComponent; c: SGChannel; VAR ud: UserData; flags: LONGINT): ComponentResult;
  1901.     {$IFC NOT GENERATINGCFM}
  1902.     INLINE $2F3C, $000C, $0209, $7000, $A82A;
  1903.     {$ENDC}
  1904. FUNCTION SGPanelSetSettings(s: SeqGrabComponent; c: SGChannel; ud: UserData; flags: LONGINT): ComponentResult;
  1905.     {$IFC NOT GENERATINGCFM}
  1906.     INLINE $2F3C, $000C, $020A, $7000, $A82A;
  1907.     {$ENDC}
  1908. FUNCTION SGPanelValidateInput(s: SeqGrabComponent; VAR ok: BOOLEAN): ComponentResult;
  1909.     {$IFC NOT GENERATINGCFM}
  1910.     INLINE $2F3C, $0004, $020B, $7000, $A82A;
  1911.     {$ENDC}
  1912. FUNCTION SGPanelSetEventFilter(s: SeqGrabComponent; proc: SGModalFilterUPP; refCon: LONGINT): ComponentResult;
  1913.     {$IFC NOT GENERATINGCFM}
  1914.     INLINE $2F3C, $0008, $020C, $7000, $A82A;
  1915.     {$ENDC}
  1916. { ** Sequence Grab VIDEO CHANNEL Component Stuff ** }
  1917. {
  1918.     Video stuff
  1919. }
  1920.  
  1921. TYPE
  1922.     SGCompressInfoPtr = ^SGCompressInfo;
  1923.     SGCompressInfo = RECORD
  1924.         buffer:                    Ptr;
  1925.         bufferSize:                LONGINT;
  1926.         similarity:                SInt8;
  1927.         reserved:                SInt8;
  1928.     END;
  1929.  
  1930.     SGGrabBottleProcPtr = ProcPtr;  { FUNCTION SGGrabBottle(c: SGChannel; bufferNum: INTEGER; refCon: LONGINT): ComponentResult; }
  1931.  
  1932.     SGGrabCompleteBottleProcPtr = ProcPtr;  { FUNCTION SGGrabCompleteBottle(c: SGChannel; bufferNum: INTEGER; VAR done: BOOLEAN; refCon: LONGINT): ComponentResult; }
  1933.  
  1934.     SGDisplayBottleProcPtr = ProcPtr;  { FUNCTION SGDisplayBottle(c: SGChannel; bufferNum: INTEGER; VAR mp: MatrixRecord; clipRgn: RgnHandle; refCon: LONGINT): ComponentResult; }
  1935.  
  1936.     SGCompressBottleProcPtr = ProcPtr;  { FUNCTION SGCompressBottle(c: SGChannel; bufferNum: INTEGER; refCon: LONGINT): ComponentResult; }
  1937.  
  1938.     SGCompressCompleteBottleProcPtr = ProcPtr;  { FUNCTION SGCompressCompleteBottle(c: SGChannel; bufferNum: INTEGER; VAR done: BOOLEAN; VAR ci: SGCompressInfo; refCon: LONGINT): ComponentResult; }
  1939.  
  1940.     SGAddFrameBottleProcPtr = ProcPtr;  { FUNCTION SGAddFrameBottle(c: SGChannel; bufferNum: INTEGER; atTime: TimeValue; scale: TimeScale; (CONST)VAR ci: SGCompressInfo; refCon: LONGINT): ComponentResult; }
  1941.  
  1942.     SGTransferFrameBottleProcPtr = ProcPtr;  { FUNCTION SGTransferFrameBottle(c: SGChannel; bufferNum: INTEGER; VAR mp: MatrixRecord; clipRgn: RgnHandle; refCon: LONGINT): ComponentResult; }
  1943.  
  1944.     SGGrabCompressCompleteBottleProcPtr = ProcPtr;  { FUNCTION SGGrabCompressCompleteBottle(c: SGChannel; VAR done: BOOLEAN; VAR ci: SGCompressInfo; VAR t: TimeRecord; refCon: LONGINT): ComponentResult; }
  1945.  
  1946.     SGDisplayCompressBottleProcPtr = ProcPtr;  { FUNCTION SGDisplayCompressBottle(c: SGChannel; dataPtr: Ptr; desc: ImageDescriptionHandle; VAR mp: MatrixRecord; clipRgn: RgnHandle; refCon: LONGINT): ComponentResult; }
  1947.  
  1948.     SGGrabBottleUPP = UniversalProcPtr;
  1949.     SGGrabCompleteBottleUPP = UniversalProcPtr;
  1950.     SGDisplayBottleUPP = UniversalProcPtr;
  1951.     SGCompressBottleUPP = UniversalProcPtr;
  1952.     SGCompressCompleteBottleUPP = UniversalProcPtr;
  1953.     SGAddFrameBottleUPP = UniversalProcPtr;
  1954.     SGTransferFrameBottleUPP = UniversalProcPtr;
  1955.     SGGrabCompressCompleteBottleUPP = UniversalProcPtr;
  1956.     SGDisplayCompressBottleUPP = UniversalProcPtr;
  1957.     VideoBottlesPtr = ^VideoBottles;
  1958.     VideoBottles = RECORD
  1959.         procCount:                INTEGER;
  1960.         grabProc:                SGGrabBottleUPP;
  1961.         grabCompleteProc:        SGGrabCompleteBottleUPP;
  1962.         displayProc:            SGDisplayBottleUPP;
  1963.         compressProc:            SGCompressBottleUPP;
  1964.         compressCompleteProc:    SGCompressCompleteBottleUPP;
  1965.         addFrameProc:            SGAddFrameBottleUPP;
  1966.         transferFrameProc:        SGTransferFrameBottleUPP;
  1967.         grabCompressCompleteProc: SGGrabCompressCompleteBottleUPP;
  1968.         displayCompressProc:    SGDisplayCompressBottleUPP;
  1969.     END;
  1970.  
  1971. FUNCTION SGGetSrcVideoBounds(c: SGChannel; VAR r: Rect): ComponentResult;
  1972.     {$IFC NOT GENERATINGCFM}
  1973.     INLINE $2F3C, $0004, $0100, $7000, $A82A;
  1974.     {$ENDC}
  1975. FUNCTION SGSetVideoRect(c: SGChannel; {CONST}VAR r: Rect): ComponentResult;
  1976.     {$IFC NOT GENERATINGCFM}
  1977.     INLINE $2F3C, $0004, $0101, $7000, $A82A;
  1978.     {$ENDC}
  1979. FUNCTION SGGetVideoRect(c: SGChannel; VAR r: Rect): ComponentResult;
  1980.     {$IFC NOT GENERATINGCFM}
  1981.     INLINE $2F3C, $0004, $0102, $7000, $A82A;
  1982.     {$ENDC}
  1983. FUNCTION SGGetVideoCompressorType(c: SGChannel; VAR compressorType: OSType): ComponentResult;
  1984.     {$IFC NOT GENERATINGCFM}
  1985.     INLINE $2F3C, $0004, $0103, $7000, $A82A;
  1986.     {$ENDC}
  1987. FUNCTION SGSetVideoCompressorType(c: SGChannel; compressorType: OSType): ComponentResult;
  1988.     {$IFC NOT GENERATINGCFM}
  1989.     INLINE $2F3C, $0004, $0104, $7000, $A82A;
  1990.     {$ENDC}
  1991. FUNCTION SGSetVideoCompressor(c: SGChannel; depth: INTEGER; compressor: CompressorComponent; spatialQuality: CodecQ; temporalQuality: CodecQ; keyFrameRate: LONGINT): ComponentResult;
  1992.     {$IFC NOT GENERATINGCFM}
  1993.     INLINE $2F3C, $0012, $0105, $7000, $A82A;
  1994.     {$ENDC}
  1995. FUNCTION SGGetVideoCompressor(c: SGChannel; VAR depth: INTEGER; VAR compressor: CompressorComponent; VAR spatialQuality: CodecQ; VAR temporalQuality: CodecQ; VAR keyFrameRate: LONGINT): ComponentResult;
  1996.     {$IFC NOT GENERATINGCFM}
  1997.     INLINE $2F3C, $0014, $0106, $7000, $A82A;
  1998.     {$ENDC}
  1999. FUNCTION SGGetVideoDigitizerComponent(c: SGChannel): ComponentInstance;
  2000.     {$IFC NOT GENERATINGCFM}
  2001.     INLINE $2F3C, $0000, $0107, $7000, $A82A;
  2002.     {$ENDC}
  2003. FUNCTION SGSetVideoDigitizerComponent(c: SGChannel; vdig: ComponentInstance): ComponentResult;
  2004.     {$IFC NOT GENERATINGCFM}
  2005.     INLINE $2F3C, $0004, $0108, $7000, $A82A;
  2006.     {$ENDC}
  2007. FUNCTION SGVideoDigitizerChanged(c: SGChannel): ComponentResult;
  2008.     {$IFC NOT GENERATINGCFM}
  2009.     INLINE $2F3C, $0000, $0109, $7000, $A82A;
  2010.     {$ENDC}
  2011. FUNCTION SGSetVideoBottlenecks(c: SGChannel; VAR vb: VideoBottles): ComponentResult;
  2012.     {$IFC NOT GENERATINGCFM}
  2013.     INLINE $2F3C, $0004, $010A, $7000, $A82A;
  2014.     {$ENDC}
  2015. FUNCTION SGGetVideoBottlenecks(c: SGChannel; VAR vb: VideoBottles): ComponentResult;
  2016.     {$IFC NOT GENERATINGCFM}
  2017.     INLINE $2F3C, $0004, $010B, $7000, $A82A;
  2018.     {$ENDC}
  2019. FUNCTION SGGrabFrame(c: SGChannel; bufferNum: INTEGER): ComponentResult;
  2020.     {$IFC NOT GENERATINGCFM}
  2021.     INLINE $2F3C, $0002, $010C, $7000, $A82A;
  2022.     {$ENDC}
  2023. FUNCTION SGGrabFrameComplete(c: SGChannel; bufferNum: INTEGER; VAR done: BOOLEAN): ComponentResult;
  2024.     {$IFC NOT GENERATINGCFM}
  2025.     INLINE $2F3C, $0006, $010D, $7000, $A82A;
  2026.     {$ENDC}
  2027. FUNCTION SGDisplayFrame(c: SGChannel; bufferNum: INTEGER; {CONST}VAR mp: MatrixRecord; clipRgn: RgnHandle): ComponentResult;
  2028.     {$IFC NOT GENERATINGCFM}
  2029.     INLINE $2F3C, $000A, $010E, $7000, $A82A;
  2030.     {$ENDC}
  2031. FUNCTION SGCompressFrame(c: SGChannel; bufferNum: INTEGER): ComponentResult;
  2032.     {$IFC NOT GENERATINGCFM}
  2033.     INLINE $2F3C, $0002, $010F, $7000, $A82A;
  2034.     {$ENDC}
  2035. FUNCTION SGCompressFrameComplete(c: SGChannel; bufferNum: INTEGER; VAR done: BOOLEAN; VAR ci: SGCompressInfo): ComponentResult;
  2036.     {$IFC NOT GENERATINGCFM}
  2037.     INLINE $2F3C, $000A, $0110, $7000, $A82A;
  2038.     {$ENDC}
  2039. FUNCTION SGAddFrame(c: SGChannel; bufferNum: INTEGER; atTime: TimeValue; scale: TimeScale; {CONST}VAR ci: SGCompressInfo): ComponentResult;
  2040.     {$IFC NOT GENERATINGCFM}
  2041.     INLINE $2F3C, $000E, $0111, $7000, $A82A;
  2042.     {$ENDC}
  2043. FUNCTION SGTransferFrameForCompress(c: SGChannel; bufferNum: INTEGER; {CONST}VAR mp: MatrixRecord; clipRgn: RgnHandle): ComponentResult;
  2044.     {$IFC NOT GENERATINGCFM}
  2045.     INLINE $2F3C, $000A, $0112, $7000, $A82A;
  2046.     {$ENDC}
  2047. FUNCTION SGSetCompressBuffer(c: SGChannel; depth: INTEGER; {CONST}VAR compressSize: Rect): ComponentResult;
  2048.     {$IFC NOT GENERATINGCFM}
  2049.     INLINE $2F3C, $0006, $0113, $7000, $A82A;
  2050.     {$ENDC}
  2051. FUNCTION SGGetCompressBuffer(c: SGChannel; VAR depth: INTEGER; VAR compressSize: Rect): ComponentResult;
  2052.     {$IFC NOT GENERATINGCFM}
  2053.     INLINE $2F3C, $0008, $0114, $7000, $A82A;
  2054.     {$ENDC}
  2055. FUNCTION SGGetBufferInfo(c: SGChannel; bufferNum: INTEGER; VAR bufferPM: PixMapHandle; VAR bufferRect: Rect; VAR compressBuffer: GWorldPtr; VAR compressBufferRect: Rect): ComponentResult;
  2056.     {$IFC NOT GENERATINGCFM}
  2057.     INLINE $2F3C, $0012, $0115, $7000, $A82A;
  2058.     {$ENDC}
  2059. FUNCTION SGSetUseScreenBuffer(c: SGChannel; useScreenBuffer: BOOLEAN): ComponentResult;
  2060.     {$IFC NOT GENERATINGCFM}
  2061.     INLINE $2F3C, $0002, $0116, $7000, $A82A;
  2062.     {$ENDC}
  2063. FUNCTION SGGetUseScreenBuffer(c: SGChannel; VAR useScreenBuffer: BOOLEAN): ComponentResult;
  2064.     {$IFC NOT GENERATINGCFM}
  2065.     INLINE $2F3C, $0004, $0117, $7000, $A82A;
  2066.     {$ENDC}
  2067. FUNCTION SGGrabCompressComplete(c: SGChannel; VAR done: BOOLEAN; VAR ci: SGCompressInfo; VAR tr: TimeRecord): ComponentResult;
  2068.     {$IFC NOT GENERATINGCFM}
  2069.     INLINE $2F3C, $000C, $0118, $7000, $A82A;
  2070.     {$ENDC}
  2071. FUNCTION SGDisplayCompress(c: SGChannel; dataPtr: Ptr; desc: ImageDescriptionHandle; VAR mp: MatrixRecord; clipRgn: RgnHandle): ComponentResult;
  2072.     {$IFC NOT GENERATINGCFM}
  2073.     INLINE $2F3C, $0010, $0119, $7000, $A82A;
  2074.     {$ENDC}
  2075. FUNCTION SGSetFrameRate(c: SGChannel; frameRate: Fixed): ComponentResult;
  2076.     {$IFC NOT GENERATINGCFM}
  2077.     INLINE $2F3C, $0004, $011A, $7000, $A82A;
  2078.     {$ENDC}
  2079. FUNCTION SGGetFrameRate(c: SGChannel; VAR frameRate: Fixed): ComponentResult;
  2080.     {$IFC NOT GENERATINGCFM}
  2081.     INLINE $2F3C, $0004, $011B, $7000, $A82A;
  2082.     {$ENDC}
  2083. FUNCTION SGSetPreferredPacketSize(c: SGChannel; preferredPacketSizeInBytes: LONGINT): ComponentResult;
  2084.     {$IFC NOT GENERATINGCFM}
  2085.     INLINE $2F3C, $0004, $0121, $7000, $A82A;
  2086.     {$ENDC}
  2087. FUNCTION SGGetPreferredPacketSize(c: SGChannel; VAR preferredPacketSizeInBytes: LONGINT): ComponentResult;
  2088.     {$IFC NOT GENERATINGCFM}
  2089.     INLINE $2F3C, $0004, $0122, $7000, $A82A;
  2090.     {$ENDC}
  2091. FUNCTION SGSetUserVideoCompressorList(c: SGChannel; compressorTypes: Handle): ComponentResult;
  2092.     {$IFC NOT GENERATINGCFM}
  2093.     INLINE $2F3C, $0004, $0123, $7000, $A82A;
  2094.     {$ENDC}
  2095. FUNCTION SGGetUserVideoCompressorList(c: SGChannel; VAR compressorTypes: Handle): ComponentResult;
  2096.     {$IFC NOT GENERATINGCFM}
  2097.     INLINE $2F3C, $0004, $0124, $7000, $A82A;
  2098.     {$ENDC}
  2099. { ** Sequence Grab SOUND CHANNEL Component Stuff ** }
  2100. {
  2101.     Sound stuff
  2102. }
  2103. FUNCTION SGSetSoundInputDriver(c: SGChannel; driverName: Str255): ComponentResult;
  2104.     {$IFC NOT GENERATINGCFM}
  2105.     INLINE $2F3C, $0004, $0100, $7000, $A82A;
  2106.     {$ENDC}
  2107. FUNCTION SGGetSoundInputDriver(c: SGChannel): LONGINT;
  2108.     {$IFC NOT GENERATINGCFM}
  2109.     INLINE $2F3C, $0000, $0101, $7000, $A82A;
  2110.     {$ENDC}
  2111. FUNCTION SGSoundInputDriverChanged(c: SGChannel): ComponentResult;
  2112.     {$IFC NOT GENERATINGCFM}
  2113.     INLINE $2F3C, $0000, $0102, $7000, $A82A;
  2114.     {$ENDC}
  2115. FUNCTION SGSetSoundRecordChunkSize(c: SGChannel; seconds: LONGINT): ComponentResult;
  2116.     {$IFC NOT GENERATINGCFM}
  2117.     INLINE $2F3C, $0004, $0103, $7000, $A82A;
  2118.     {$ENDC}
  2119. FUNCTION SGGetSoundRecordChunkSize(c: SGChannel): LONGINT;
  2120.     {$IFC NOT GENERATINGCFM}
  2121.     INLINE $2F3C, $0000, $0104, $7000, $A82A;
  2122.     {$ENDC}
  2123. FUNCTION SGSetSoundInputRate(c: SGChannel; rate: Fixed): ComponentResult;
  2124.     {$IFC NOT GENERATINGCFM}
  2125.     INLINE $2F3C, $0004, $0105, $7000, $A82A;
  2126.     {$ENDC}
  2127. FUNCTION SGGetSoundInputRate(c: SGChannel): Fixed;
  2128.     {$IFC NOT GENERATINGCFM}
  2129.     INLINE $2F3C, $0000, $0106, $7000, $A82A;
  2130.     {$ENDC}
  2131. FUNCTION SGSetSoundInputParameters(c: SGChannel; sampleSize: INTEGER; numChannels: INTEGER; compressionType: OSType): ComponentResult;
  2132.     {$IFC NOT GENERATINGCFM}
  2133.     INLINE $2F3C, $0008, $0107, $7000, $A82A;
  2134.     {$ENDC}
  2135. FUNCTION SGGetSoundInputParameters(c: SGChannel; VAR sampleSize: INTEGER; VAR numChannels: INTEGER; VAR compressionType: OSType): ComponentResult;
  2136.     {$IFC NOT GENERATINGCFM}
  2137.     INLINE $2F3C, $000C, $0108, $7000, $A82A;
  2138.     {$ENDC}
  2139. FUNCTION SGSetAdditionalSoundRates(c: SGChannel; rates: Handle): ComponentResult;
  2140.     {$IFC NOT GENERATINGCFM}
  2141.     INLINE $2F3C, $0004, $0109, $7000, $A82A;
  2142.     {$ENDC}
  2143. FUNCTION SGGetAdditionalSoundRates(c: SGChannel; VAR rates: Handle): ComponentResult;
  2144.     {$IFC NOT GENERATINGCFM}
  2145.     INLINE $2F3C, $0004, $010A, $7000, $A82A;
  2146.     {$ENDC}
  2147. {
  2148.     Text stuff
  2149. }
  2150. FUNCTION SGSetFontName(c: SGChannel; pstr: StringPtr): ComponentResult;
  2151.     {$IFC NOT GENERATINGCFM}
  2152.     INLINE $2F3C, $0004, $0100, $7000, $A82A;
  2153.     {$ENDC}
  2154. FUNCTION SGSetFontSize(c: SGChannel; fontSize: INTEGER): ComponentResult;
  2155.     {$IFC NOT GENERATINGCFM}
  2156.     INLINE $2F3C, $0002, $0101, $7000, $A82A;
  2157.     {$ENDC}
  2158. FUNCTION SGSetTextForeColor(c: SGChannel; VAR theColor: RGBColor): ComponentResult;
  2159.     {$IFC NOT GENERATINGCFM}
  2160.     INLINE $2F3C, $0004, $0102, $7000, $A82A;
  2161.     {$ENDC}
  2162. FUNCTION SGSetTextBackColor(c: SGChannel; VAR theColor: RGBColor): ComponentResult;
  2163.     {$IFC NOT GENERATINGCFM}
  2164.     INLINE $2F3C, $0004, $0103, $7000, $A82A;
  2165.     {$ENDC}
  2166. FUNCTION SGSetJustification(c: SGChannel; just: INTEGER): ComponentResult;
  2167.     {$IFC NOT GENERATINGCFM}
  2168.     INLINE $2F3C, $0002, $0104, $7000, $A82A;
  2169.     {$ENDC}
  2170. FUNCTION SGGetTextReturnToSpaceValue(c: SGChannel; VAR rettospace: INTEGER): ComponentResult;
  2171.     {$IFC NOT GENERATINGCFM}
  2172.     INLINE $2F3C, $0004, $0105, $7000, $A82A;
  2173.     {$ENDC}
  2174. FUNCTION SGSetTextReturnToSpaceValue(c: SGChannel; rettospace: INTEGER): ComponentResult;
  2175.     {$IFC NOT GENERATINGCFM}
  2176.     INLINE $2F3C, $0002, $0106, $7000, $A82A;
  2177.     {$ENDC}
  2178. {
  2179.     Music stuff
  2180. }
  2181. FUNCTION SGGetInstrument(c: SGChannel; VAR td: ToneDescription): ComponentResult;
  2182.     {$IFC NOT GENERATINGCFM}
  2183.     INLINE $2F3C, $0004, $0100, $7000, $A82A;
  2184.     {$ENDC}
  2185. FUNCTION SGSetInstrument(c: SGChannel; VAR td: ToneDescription): ComponentResult;
  2186.     {$IFC NOT GENERATINGCFM}
  2187.     INLINE $2F3C, $0004, $0101, $7000, $A82A;
  2188.     {$ENDC}
  2189.  
  2190. CONST
  2191.     sgChannelAtom                = 'chan';
  2192.     sgChannelSettingsAtom        = 'ctom';
  2193.     sgChannelDescription        = 'cdsc';
  2194.     sgChannelSettings            = 'cset';
  2195.  
  2196.     sgDeviceNameType            = 'name';
  2197.     sgUsageType                    = 'use ';
  2198.     sgPlayFlagsType                = 'plyf';
  2199.     sgClipType                    = 'clip';
  2200.     sgMatrixType                = 'mtrx';
  2201.     sgVolumeType                = 'volu';
  2202.  
  2203.     sgPanelSettingsAtom            = 'ptom';
  2204.     sgPanelDescription            = 'pdsc';
  2205.     sgPanelSettings                = 'pset';
  2206.  
  2207.     sgcSoundCompressionType        = 'scmp';
  2208.     sgcSoundSampleRateType        = 'srat';
  2209.     sgcSoundChannelCountType    = 'schn';
  2210.     sgcSoundSampleSizeType        = 'ssiz';
  2211.     sgcSoundInputType            = 'sinp';
  2212.     sgcSoundGainType            = 'gain';
  2213.  
  2214.     sgcVideoHueType                = 'hue ';
  2215.     sgcVideoSaturationType        = 'satr';
  2216.     sgcVideoContrastType        = 'trst';
  2217.     sgcVideoSharpnessType        = 'shrp';
  2218.     sgcVideoBrigtnessType        = 'brit';
  2219.     sgcVideoBlackLevelType        = 'blkl';
  2220.     sgcVideoWhiteLevelType        = 'whtl';
  2221.     sgcVideoInputType            = 'vinp';
  2222.     sgcVideoFormatType            = 'vstd';
  2223.     sgcVideoFilterType            = 'vflt';
  2224.     sgcVideoRectType            = 'vrct';
  2225.     sgcVideoDigitizerType        = 'vdig';
  2226.  
  2227. {  UPP call backs  }
  2228.     uppSCModalFilterProcInfo = $00003FD0;
  2229.     uppSCModalHookProcInfo = $00003EE0;
  2230.     uppTweenerDataProcInfo = $003FFFF0;
  2231.     uppDataHCompletionProcInfo = $00000BC0;
  2232.     uppVdigIntProcInfo = $000003C0;
  2233.     uppSGDataProcInfo = $003BFFE0;
  2234.     uppSGModalFilterProcInfo = $00003FD0;
  2235.     uppSGGrabBottleProcInfo = $00000EF0;
  2236.     uppSGGrabCompleteBottleProcInfo = $00003EF0;
  2237.     uppSGDisplayBottleProcInfo = $0000FEF0;
  2238.     uppSGCompressBottleProcInfo = $00000EF0;
  2239.     uppSGCompressCompleteBottleProcInfo = $0000FEF0;
  2240.     uppSGAddFrameBottleProcInfo = $0003FEF0;
  2241.     uppSGTransferFrameBottleProcInfo = $0000FEF0;
  2242.     uppSGGrabCompressCompleteBottleProcInfo = $0000FFF0;
  2243.     uppSGDisplayCompressBottleProcInfo = $0003FFF0;
  2244.  
  2245. FUNCTION NewSCModalFilterProc(userRoutine: SCModalFilterProcPtr): SCModalFilterUPP;
  2246.     {$IFC NOT GENERATINGCFM }
  2247.     INLINE $2E9F;
  2248.     {$ENDC}
  2249.  
  2250. FUNCTION NewSCModalHookProc(userRoutine: SCModalHookProcPtr): SCModalHookUPP;
  2251.     {$IFC NOT GENERATINGCFM }
  2252.     INLINE $2E9F;
  2253.     {$ENDC}
  2254.  
  2255. FUNCTION NewTweenerDataProc(userRoutine: TweenerDataProcPtr): TweenerDataUPP;
  2256.     {$IFC NOT GENERATINGCFM }
  2257.     INLINE $2E9F;
  2258.     {$ENDC}
  2259.  
  2260. FUNCTION NewDataHCompletionProc(userRoutine: DataHCompletionProcPtr): DataHCompletionUPP;
  2261.     {$IFC NOT GENERATINGCFM }
  2262.     INLINE $2E9F;
  2263.     {$ENDC}
  2264.  
  2265. FUNCTION NewVdigIntProc(userRoutine: VdigIntProcPtr): VdigIntUPP;
  2266.     {$IFC NOT GENERATINGCFM }
  2267.     INLINE $2E9F;
  2268.     {$ENDC}
  2269.  
  2270. FUNCTION NewSGDataProc(userRoutine: SGDataProcPtr): SGDataUPP;
  2271.     {$IFC NOT GENERATINGCFM }
  2272.     INLINE $2E9F;
  2273.     {$ENDC}
  2274.  
  2275. FUNCTION NewSGModalFilterProc(userRoutine: SGModalFilterProcPtr): SGModalFilterUPP;
  2276.     {$IFC NOT GENERATINGCFM }
  2277.     INLINE $2E9F;
  2278.     {$ENDC}
  2279.  
  2280. FUNCTION NewSGGrabBottleProc(userRoutine: SGGrabBottleProcPtr): SGGrabBottleUPP;
  2281.     {$IFC NOT GENERATINGCFM }
  2282.     INLINE $2E9F;
  2283.     {$ENDC}
  2284.  
  2285. FUNCTION NewSGGrabCompleteBottleProc(userRoutine: SGGrabCompleteBottleProcPtr): SGGrabCompleteBottleUPP;
  2286.     {$IFC NOT GENERATINGCFM }
  2287.     INLINE $2E9F;
  2288.     {$ENDC}
  2289.  
  2290. FUNCTION NewSGDisplayBottleProc(userRoutine: SGDisplayBottleProcPtr): SGDisplayBottleUPP;
  2291.     {$IFC NOT GENERATINGCFM }
  2292.     INLINE $2E9F;
  2293.     {$ENDC}
  2294.  
  2295. FUNCTION NewSGCompressBottleProc(userRoutine: SGCompressBottleProcPtr): SGCompressBottleUPP;
  2296.     {$IFC NOT GENERATINGCFM }
  2297.     INLINE $2E9F;
  2298.     {$ENDC}
  2299.  
  2300. FUNCTION NewSGCompressCompleteBottleProc(userRoutine: SGCompressCompleteBottleProcPtr): SGCompressCompleteBottleUPP;
  2301.     {$IFC NOT GENERATINGCFM }
  2302.     INLINE $2E9F;
  2303.     {$ENDC}
  2304.  
  2305. FUNCTION NewSGAddFrameBottleProc(userRoutine: SGAddFrameBottleProcPtr): SGAddFrameBottleUPP;
  2306.     {$IFC NOT GENERATINGCFM }
  2307.     INLINE $2E9F;
  2308.     {$ENDC}
  2309.  
  2310. FUNCTION NewSGTransferFrameBottleProc(userRoutine: SGTransferFrameBottleProcPtr): SGTransferFrameBottleUPP;
  2311.     {$IFC NOT GENERATINGCFM }
  2312.     INLINE $2E9F;
  2313.     {$ENDC}
  2314.  
  2315. FUNCTION NewSGGrabCompressCompleteBottleProc(userRoutine: SGGrabCompressCompleteBottleProcPtr): SGGrabCompressCompleteBottleUPP;
  2316.     {$IFC NOT GENERATINGCFM }
  2317.     INLINE $2E9F;
  2318.     {$ENDC}
  2319.  
  2320. FUNCTION NewSGDisplayCompressBottleProc(userRoutine: SGDisplayCompressBottleProcPtr): SGDisplayCompressBottleUPP;
  2321.     {$IFC NOT GENERATINGCFM }
  2322.     INLINE $2E9F;
  2323.     {$ENDC}
  2324.  
  2325. FUNCTION CallSCModalFilterProc(theDialog: DialogPtr; VAR theEvent: EventRecord; VAR itemHit: INTEGER; refcon: LONGINT; userRoutine: SCModalFilterUPP): BOOLEAN;
  2326.     {$IFC NOT GENERATINGCFM}
  2327.     INLINE $205F, $4E90;
  2328.     {$ENDC}
  2329.  
  2330. FUNCTION CallSCModalHookProc(theDialog: DialogPtr; itemHit: INTEGER; params: UNIV Ptr; refcon: LONGINT; userRoutine: SCModalHookUPP): INTEGER;
  2331.     {$IFC NOT GENERATINGCFM}
  2332.     INLINE $205F, $4E90;
  2333.     {$ENDC}
  2334.  
  2335. FUNCTION CallTweenerDataProc(VAR tr: TweenRecord; tweenData: UNIV Ptr; tweenDataSize: LONGINT; dataDescriptionSeed: LONGINT; dataDescription: Handle; asyncCompletionProc: ICMCompletionProcRecordPtr; transferProc: ProcPtr; refCon: UNIV Ptr; userRoutine: TweenerDataUPP): ComponentResult;
  2336.     {$IFC NOT GENERATINGCFM}
  2337.     INLINE $205F, $4E90;
  2338.     {$ENDC}
  2339.  
  2340. PROCEDURE CallDataHCompletionProc(request: Ptr; refcon: LONGINT; err: OSErr; userRoutine: DataHCompletionUPP);
  2341.     {$IFC NOT GENERATINGCFM}
  2342.     INLINE $205F, $4E90;
  2343.     {$ENDC}
  2344.  
  2345. PROCEDURE CallVdigIntProc(flags: LONGINT; refcon: LONGINT; userRoutine: VdigIntUPP);
  2346.     {$IFC NOT GENERATINGCFM}
  2347.     INLINE $205F, $4E90;
  2348.     {$ENDC}
  2349.  
  2350. FUNCTION CallSGDataProc(c: SGChannel; p: Ptr; len: LONGINT; VAR offset: LONGINT; chRefCon: LONGINT; time: TimeValue; writeType: INTEGER; refCon: LONGINT; userRoutine: SGDataUPP): OSErr;
  2351.     {$IFC NOT GENERATINGCFM}
  2352.     INLINE $205F, $4E90;
  2353.     {$ENDC}
  2354.  
  2355. FUNCTION CallSGModalFilterProc(theDialog: DialogPtr; VAR theEvent: EventRecord; VAR itemHit: INTEGER; refCon: LONGINT; userRoutine: SGModalFilterUPP): BOOLEAN;
  2356.     {$IFC NOT GENERATINGCFM}
  2357.     INLINE $205F, $4E90;
  2358.     {$ENDC}
  2359.  
  2360. FUNCTION CallSGGrabBottleProc(c: SGChannel; bufferNum: INTEGER; refCon: LONGINT; userRoutine: SGGrabBottleUPP): ComponentResult;
  2361.     {$IFC NOT GENERATINGCFM}
  2362.     INLINE $205F, $4E90;
  2363.     {$ENDC}
  2364.  
  2365. FUNCTION CallSGGrabCompleteBottleProc(c: SGChannel; bufferNum: INTEGER; VAR done: BOOLEAN; refCon: LONGINT; userRoutine: SGGrabCompleteBottleUPP): ComponentResult;
  2366.     {$IFC NOT GENERATINGCFM}
  2367.     INLINE $205F, $4E90;
  2368.     {$ENDC}
  2369.  
  2370. FUNCTION CallSGDisplayBottleProc(c: SGChannel; bufferNum: INTEGER; VAR mp: MatrixRecord; clipRgn: RgnHandle; refCon: LONGINT; userRoutine: SGDisplayBottleUPP): ComponentResult;
  2371.     {$IFC NOT GENERATINGCFM}
  2372.     INLINE $205F, $4E90;
  2373.     {$ENDC}
  2374.  
  2375. FUNCTION CallSGCompressBottleProc(c: SGChannel; bufferNum: INTEGER; refCon: LONGINT; userRoutine: SGCompressBottleUPP): ComponentResult;
  2376.     {$IFC NOT GENERATINGCFM}
  2377.     INLINE $205F, $4E90;
  2378.     {$ENDC}
  2379.  
  2380. FUNCTION CallSGCompressCompleteBottleProc(c: SGChannel; bufferNum: INTEGER; VAR done: BOOLEAN; VAR ci: SGCompressInfo; refCon: LONGINT; userRoutine: SGCompressCompleteBottleUPP): ComponentResult;
  2381.     {$IFC NOT GENERATINGCFM}
  2382.     INLINE $205F, $4E90;
  2383.     {$ENDC}
  2384.  
  2385. FUNCTION CallSGAddFrameBottleProc(c: SGChannel; bufferNum: INTEGER; atTime: TimeValue; scale: TimeScale; {CONST}VAR ci: SGCompressInfo; refCon: LONGINT; userRoutine: SGAddFrameBottleUPP): ComponentResult;
  2386.     {$IFC NOT GENERATINGCFM}
  2387.     INLINE $205F, $4E90;
  2388.     {$ENDC}
  2389.  
  2390. FUNCTION CallSGTransferFrameBottleProc(c: SGChannel; bufferNum: INTEGER; VAR mp: MatrixRecord; clipRgn: RgnHandle; refCon: LONGINT; userRoutine: SGTransferFrameBottleUPP): ComponentResult;
  2391.     {$IFC NOT GENERATINGCFM}
  2392.     INLINE $205F, $4E90;
  2393.     {$ENDC}
  2394.  
  2395. FUNCTION CallSGGrabCompressCompleteBottleProc(c: SGChannel; VAR done: BOOLEAN; VAR ci: SGCompressInfo; VAR t: TimeRecord; refCon: LONGINT; userRoutine: SGGrabCompressCompleteBottleUPP): ComponentResult;
  2396.     {$IFC NOT GENERATINGCFM}
  2397.     INLINE $205F, $4E90;
  2398.     {$ENDC}
  2399.  
  2400. FUNCTION CallSGDisplayCompressBottleProc(c: SGChannel; dataPtr: Ptr; desc: ImageDescriptionHandle; VAR mp: MatrixRecord; clipRgn: RgnHandle; refCon: LONGINT; userRoutine: SGDisplayCompressBottleUPP): ComponentResult;
  2401.     {$IFC NOT GENERATINGCFM}
  2402.     INLINE $205F, $4E90;
  2403.     {$ENDC}
  2404.  
  2405. {$ALIGN RESET}
  2406. {$POP}
  2407.  
  2408. {$SETC UsingIncludes := QuickTimeComponentsIncludes}
  2409.  
  2410. {$ENDC} {__QUICKTIMECOMPONENTS__}
  2411.  
  2412. {$IFC NOT UsingIncludes}
  2413.  END.
  2414. {$ENDC}
  2415.